braintree 2.2.0 → 2.3.1

data/spec/integration/braintree/transparent_redirect_spec.rb

@@ -3,7 +3,7 @@ require File.dirname(__FILE__) + "/../spec_helper"
 describe Braintree::TransparentRedirect do
   it "raises a DownForMaintenanceError when app is in maintenance mode on TR requests" do
     tr_data = Braintree::TransparentRedirect.create_customer_data({:redirect_url => "http://example.com"}.merge({}))
-    query_string_response = SpecHelper.simulate_form_post_for_tr(Braintree::Configuration.base_merchant_url + "/test/maintenance", tr_data, {})
+    query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, {}, Braintree::Configuration.base_merchant_url + "/test/maintenance")
     expect do
       Braintree::Customer.create_from_transparent_redirect(query_string_response)
     end.to raise_error(Braintree::DownForMaintenanceError)
@@ -12,10 +12,225 @@ describe Braintree::TransparentRedirect do
   it "raises an AuthenticationError when authentication fails on TR requests" do
     SpecHelper.using_configuration(:private_key => "incorrect") do
       tr_data = Braintree::TransparentRedirect.create_customer_data({:redirect_url => "http://example.com"}.merge({}))
-      query_string_response = SpecHelper.simulate_form_post_for_tr(Braintree::Customer.create_customer_url, tr_data, {})
+      query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, {}, Braintree::Customer.create_customer_url)
       expect do
         Braintree::Customer.create_from_transparent_redirect(query_string_response)
       end.to raise_error(Braintree::AuthenticationError)
     end
   end
+
+  describe "self.confirm" do
+    context "transaction" do
+      it "successfully confirms a transaction create" do
+        params = {
+          :transaction => {
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/2009"
+            }
+          }
+        }
+        tr_data_params = {
+          :transaction => {
+            :type => "sale"
+          }
+        }
+        tr_data = Braintree::TransparentRedirect.transaction_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
+        query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params)
+        result = Braintree::TransparentRedirect.confirm(query_string_response)
+
+        result.success?.should == true
+        transaction = result.transaction
+        transaction.type.should == "sale"
+        transaction.amount.should == BigDecimal.new("1000.00")
+        transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
+        transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
+        transaction.credit_card_details.expiration_date.should == "05/2009"
+      end
+
+      it "returns an error when there's an error" do
+        params = {
+          :transaction => {
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => "abc",
+              :expiration_date => "05/2009"
+            }
+          }
+        }
+        tr_data_params = {
+          :transaction => {
+            :type => "sale"
+          }
+        }
+        tr_data = Braintree::TransparentRedirect.transaction_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
+        query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params)
+        result = Braintree::TransparentRedirect.confirm(query_string_response)
+
+        result.success?.should == false
+        result.errors.for(:transaction).for(:credit_card).on(:number).size.should > 0
+      end
+    end
+
+    context "customer" do
+      it "successfully confirms a customer create" do
+        params = {
+          :customer => {
+            :first_name => "John",
+          }
+        }
+        tr_data_params = {
+          :customer => {
+            :last_name => "Doe",
+          }
+        }
+        tr_data = Braintree::TransparentRedirect.create_customer_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
+        query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params)
+        result = Braintree::TransparentRedirect.confirm(query_string_response)
+
+        result.success?.should == true
+        customer = result.customer
+        customer.first_name.should == "John"
+        customer.last_name.should == "Doe"
+      end
+
+      it "successfully confirms a customer update" do
+        customer = Braintree::Customer.create(
+          :first_name => "Joe",
+          :last_name => "Cool"
+        ).customer
+
+        params = {
+          :customer => {
+            :first_name => "John",
+          }
+        }
+        tr_data_params = {
+          :customer_id => customer.id,
+          :customer => {
+            :last_name => "Uncool",
+          }
+        }
+        tr_data = Braintree::TransparentRedirect.update_customer_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
+        query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params)
+        result = Braintree::TransparentRedirect.confirm(query_string_response)
+
+        result.success?.should == true
+        customer = Braintree::Customer.find(customer.id)
+        customer.first_name.should == "John"
+        customer.last_name.should == "Uncool"
+      end
+
+      it "returns an error result when there are errors" do
+        params = {
+          :customer => {
+            :first_name => "John",
+          }
+        }
+        tr_data_params = {
+          :customer => {
+            :last_name => "Doe",
+            :email => "invalid"
+          }
+        }
+        tr_data = Braintree::TransparentRedirect.create_customer_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
+        query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params)
+        result = Braintree::TransparentRedirect.confirm(query_string_response)
+
+        result.success?.should == false
+        result.errors.for(:customer).on(:email).size.should > 0
+      end
+    end
+
+    context "credit_card" do
+      it "successfully confirms a credit_card create" do
+        customer = Braintree::Customer.create(:first_name => "John", :last_name => "Doe").customer
+
+        params = {
+          :credit_card => {
+            :cardholder_name => "John Doe"
+          }
+        }
+        tr_data_params = {
+          :credit_card => {
+            :customer_id => customer.id,
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "10/10"
+          }
+        }
+        tr_data = Braintree::TransparentRedirect.create_credit_card_data(
+          {:redirect_url => "http://example.com"}.merge(tr_data_params)
+        )
+        query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params)
+        result = Braintree::TransparentRedirect.confirm(query_string_response)
+
+        result.success?.should == true
+        credit_card = result.credit_card
+        credit_card.cardholder_name.should == "John Doe"
+        credit_card.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
+        credit_card.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
+        credit_card.expiration_date.should == "10/2010"
+      end
+
+      it "successfully confirms a credit_card update" do
+        customer = Braintree::Customer.create(:first_name => "John", :last_name => "Doe").customer
+        credit_card = Braintree::CreditCard.create(
+          :customer_id => customer.id,
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "10/10"
+        ).credit_card
+
+        params = {
+          :credit_card => {
+            :cardholder_name => "John Doe"
+          }
+        }
+        tr_data_params = {
+          :payment_method_token => credit_card.token,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::MasterCard,
+            :expiration_date => "11/11"
+          }
+        }
+        tr_data = Braintree::TransparentRedirect.update_credit_card_data(
+          {:redirect_url => "http://example.com"}.merge(tr_data_params)
+        )
+        query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params)
+        result = Braintree::TransparentRedirect.confirm(query_string_response)
+
+        result.success?.should == true
+        credit_card = result.credit_card
+        credit_card.cardholder_name.should == "John Doe"
+        credit_card.bin.should == Braintree::Test::CreditCardNumbers::MasterCard[0, 6]
+        credit_card.last_4.should == Braintree::Test::CreditCardNumbers::MasterCard[-4..-1]
+        credit_card.expiration_date.should == "11/2011"
+      end
+
+      it "returns an error result where there are errors" do
+        customer = Braintree::Customer.create(:first_name => "John", :last_name => "Doe").customer
+
+        params = {
+          :credit_card => {
+            :cardholder_name => "John Doe"
+          }
+        }
+        tr_data_params = {
+          :credit_card => {
+            :customer_id => customer.id,
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "123"
+          }
+        }
+        tr_data = Braintree::TransparentRedirect.create_credit_card_data(
+          {:redirect_url => "http://example.com"}.merge(tr_data_params)
+        )
+        query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params)
+        result = Braintree::TransparentRedirect.confirm(query_string_response)
+
+        result.success?.should == false
+        result.errors.for(:credit_card).size.should > 0
+      end
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -4,6 +4,7 @@ unless defined?(SPEC_HELPER_LOADED)
   project_root = File.expand_path(File.dirname(__FILE__) + "/..")
   require "rubygems"
   gem "libxml-ruby", ENV["LIBXML_VERSION"] || "1.1.3"
+  require "libxml"
   gem "builder", ENV["BUILDER_VERSION"] || "2.1.2"
   braintree_lib = "#{project_root}/lib"
   $LOAD_PATH << braintree_lib
@@ -16,6 +17,14 @@ unless defined?(SPEC_HELPER_LOADED)
   Braintree::Configuration.logger = Logger.new("/dev/null")
   Braintree::Configuration.logger.level = Logger::INFO
 
+  module Kernel
+    alias_method :original_warn, :warn
+    def warn(message)
+      return if message =~ /^\[DEPRECATED\]/
+      original_warn(message)
+    end
+  end
+
   module SpecHelper
 
     DefaultMerchantAccountId = "sandbox_credit_card"
@@ -39,7 +48,7 @@ unless defined?(SPEC_HELPER_LOADED)
       end
     end
 
-    def self.simulate_form_post_for_tr(url, tr_data_string, form_data_hash)
+    def self.simulate_form_post_for_tr(tr_data_string, form_data_hash, url=Braintree::TransparentRedirect.url)
       response = nil
       Net::HTTP.start("localhost", Braintree::Configuration.port) do |http|
         request = Net::HTTP::Post.new("/" + url.split("/", 4)[3])
@@ -71,6 +80,45 @@ unless defined?(SPEC_HELPER_LOADED)
       end
     end
   end
+
+  module CustomMatchers
+    class ParseTo
+      def initialize(hash)
+        @expected_hash = hash
+      end
+
+      def matches?(xml_string)
+        @libxml_parse = Braintree::Xml::Parser.hash_from_xml(xml_string, Braintree::Xml::Libxml)
+        @rexml_parse = Braintree::Xml::Parser.hash_from_xml(xml_string, Braintree::Xml::Rexml)
+        if @libxml_parse != @expected_hash
+          @results = @libxml_parse
+          @failed_parser = "libxml"
+          false
+        elsif @rexml_parse != @expected_hash
+          @results = @rexml_parse
+          @failed_parser = "rexml"
+          false
+        else
+          true
+        end
+      end
+
+      def failure_message
+        "xml parsing failed for #{@failed_parser}, expected #{@expected_hash.inspect} but was #{@results.inspect}"
+      end
+
+      def negative_failure_message
+        raise NotImplementedError
+      end
+    end
+
+    def parse_to(hash)
+      ParseTo.new(hash)
+    end
+  end
+
+  Spec::Runner.configure do |config|
+    config.include CustomMatchers
+  end
 end
 
-Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f}

data/spec/unit/braintree/credit_card_spec.rb

@@ -19,7 +19,7 @@ describe Braintree::CreditCard do
         :expiration_year,
         :number,
         :token,
-        {:options => [:make_default, :verify_card]},
+        {:options => [:make_default, :verification_merchant_account_id, :verify_card]},
         {:billing_address => [
           :company,
           :country_name,
@@ -46,7 +46,7 @@ describe Braintree::CreditCard do
         :expiration_year,
         :number,
         :token,
-        {:options => [:make_default, :verify_card]},
+        {:options => [:make_default, :verification_merchant_account_id, :verify_card]},
         {:billing_address => [
           :company,
           :country_name,
@@ -111,25 +111,6 @@ describe Braintree::CreditCard do
     end
   end
 
-  describe "expired?" do
-    it "is true if the payment method is this year and the month has passed" do
-      SpecHelper.stub_time_dot_now(Time.mktime(2009, 10, 20)) do
-        expired_pm = Braintree::CreditCard._new(:expiration_month => "09", :expiration_year => "2009")
-        expired_pm.expired?.should == true
-      end
-    end
-
-    it "is true if the payment method is in a previous year" do
-      expired_pm = Braintree::CreditCard._new(:expiration_month => "12", :expiration_year => (Time.now.year - 1).to_s)
-      expired_pm.expired?.should == true
-    end
-
-    it "is false if the payment method is not expired" do
-      not_expired_pm = Braintree::CreditCard._new(:expiration_month => "01", :expiration_year => (Time.now.year + 1).to_s)
-      not_expired_pm.expired?.should == false
-    end
-  end
-
   describe "inspect" do
     it "includes the token first" do
       output = Braintree::CreditCard._new(:token => "cc123").inspect

data/spec/unit/braintree/credit_card_verification_spec.rb

@@ -10,9 +10,10 @@ describe Braintree::CreditCardVerification do
         :avs_street_address_response_code => "I",
         :cvv_response_code => "I",
         :processor_response_code => "2000",
-        :processor_response_text => "Do Not Honor"
+        :processor_response_text => "Do Not Honor",
+        :merchant_account_id => "some_id"
       )
-      verification.inspect.should == %(#<Braintree::CreditCardVerification status: "verified", processor_response_code: "2000", processor_response_text: "Do Not Honor", cvv_response_code: "I", avs_error_response_code: "I", avs_postal_code_response_code: "I", avs_street_address_response_code: "I">)
+      verification.inspect.should == %(#<Braintree::CreditCardVerification status: "verified", processor_response_code: "2000", processor_response_text: "Do Not Honor", cvv_response_code: "I", avs_error_response_code: "I", avs_postal_code_response_code: "I", avs_street_address_response_code: "I", merchant_account_id: "some_id">)
     end
   end
 end

data/spec/unit/braintree/customer_spec.rb

@@ -48,6 +48,86 @@ describe Braintree::Customer do
     end
   end
 
+  describe "self.create_signature" do
+    it "should be what we expect" do
+      Braintree::Customer._create_signature.should == [
+        :company,
+        :email,
+        :fax,
+        :first_name,
+        :id,
+        :last_name,
+        :phone,
+        :website,
+        {:credit_card => [
+          :cardholder_name,
+          :cvv,
+          :expiration_date,
+          :expiration_month,
+          :expiration_year,
+          :number,
+          :token,
+          {:options => [:make_default, :verification_merchant_account_id, :verify_card]},
+          {:billing_address => [
+            :company,
+            :country_name,
+            :extended_address,
+            :first_name,
+            :last_name,
+            :locality,
+            :postal_code,
+            :region,
+            :street_address
+          ]}
+        ]},
+        {:custom_fields => :_any_key_}
+      ]
+    end
+  end
+
+  describe "self.update_signature" do
+    it "should be what we expect" do
+      Braintree::Customer._update_signature.should == [
+        :company,
+        :email,
+        :fax,
+        :first_name,
+        :id,
+        :last_name,
+        :phone,
+        :website,
+        {:credit_card => [
+          :cardholder_name,
+          :cvv,
+          :expiration_date,
+          :expiration_month,
+          :expiration_year,
+          :number,
+          :token,
+          {:options => [
+            :make_default,
+            :verification_merchant_account_id,
+            :verify_card,
+            :update_existing_token
+          ]},
+          {:billing_address => [
+            :company,
+            :country_name,
+            :extended_address,
+            :first_name,
+            :last_name,
+            :locality,
+            :postal_code,
+            :region,
+            :street_address,
+            {:options => [:update_existing]}
+          ]}
+        ]},
+        {:custom_fields => :_any_key_}
+      ]
+    end
+  end
+
   describe "self.create_from_transparent_redirect" do
     it "raises an exception if the query string is forged" do
       expect do