braintree 2.25.0 → 2.26.0

data/spec/httpsd.pid

@@ -1 +1 @@
-4742
+4588

data/spec/integration/braintree/credit_card_spec.rb

@@ -34,7 +34,8 @@ describe Braintree::CreditCard do
         :number => Braintree::Test::CreditCardNumbers::Visa,
         :expiration_date => "05/2009",
         :cvv => "100",
-        :device_session_id => "abc123"
+        :device_session_id => "abc123",
+        :fraud_merchant_id => "7"
       )
       result.success?.should == true
     end

data/spec/integration/braintree/customer_spec.rb

@@ -53,13 +53,14 @@ describe Braintree::Customer do
       result.customer.updated_at.between?(Time.now - 10, Time.now).should == true
     end
 
-    it "supports creation with a device session ID" do
+    it "supports creation with a device session ID and (optional) fraud_merchant_id" do
       result = Braintree::Customer.create(
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::MasterCard,
           :expiration_date => "05/2010",
           :cvv => "100",
-          :device_session_id => "abc123"
+          :device_session_id => "abc123",
+          :fraud_merchant_id => "7"
         }
       )
 

data/spec/integration/braintree/http_spec.rb

@@ -113,6 +113,20 @@ describe Braintree::Http do
         end
       end
 
+      it "accepts the certificate on the qa server" do
+        begin
+          original_env = Braintree::Configuration.environment
+          Braintree::Configuration.environment = :qa
+          Braintree::Configuration.stub(:base_merchant_path).and_return("/")
+
+          expect do
+            Braintree::Configuration.instantiate.http._http_do(Net::HTTP::Get, "/login")
+          end.to_not raise_error
+        ensure
+          Braintree::Configuration.environment = original_env
+        end
+      end
+
       it "accepts the certificate on the sandbox server" do
         begin
           original_env = Braintree::Configuration.environment

data/spec/integration/braintree/merchant_account_spec.rb

@@ -14,7 +14,7 @@ VALID_APPLICATION_PARAMS = {
     },
     :date_of_birth => "10/9/1980",
     :ssn => "123-00-1234",
-    :routing_number => "1234567890",
+    :routing_number => "121000248",
     :account_number => "43759348798"
   },
   :tos_accepted => true,
@@ -54,7 +54,9 @@ describe Braintree::MerchantAccount do
 
     it "requires all fields" do
       result = Braintree::MerchantAccount.create(
-        :master_merchant_account_id => "sandbox_master_merchant_account"
+        :master_merchant_account_id => "sandbox_master_merchant_account",
+        :tos_accepted => true,
+        :applicant_details => {}
       )
       result.should_not be_success
       result.errors.for(:merchant_account).for(:applicant_details).on(:first_name).first.code.should == Braintree::ErrorCodes::MerchantAccount::ApplicantDetails::FirstNameIsRequired

data/spec/integration/braintree/transaction_search_spec.rb

@@ -1090,5 +1090,15 @@ describe Braintree::Transaction, "search" do
         collection.maximum_size.should == 0
       end
     end
+
+    context "when the search times out" do
+      it "raises a Down for Maintenance Error" do
+        expect {
+          collection = Braintree::Transaction.search do |search|
+            search.amount.is -10
+          end
+        }.to raise_error(Braintree::DownForMaintenanceError)
+      end
+    end
   end
 end

data/spec/integration/braintree/transaction_spec.rb

@@ -149,13 +149,14 @@ describe Braintree::Transaction do
       result.transaction.type.should == "sale"
       result.transaction.amount.should == BigDecimal.new(Braintree::Test::TransactionAmounts::Authorize)
       result.transaction.processor_authorization_code.should_not be_nil
+      result.transaction.voice_referral_number.should be_nil
       result.transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
       result.transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
       result.transaction.credit_card_details.expiration_date.should == "05/2009"
       result.transaction.credit_card_details.customer_location.should == "US"
     end
 
-    it "accepts additional security parameters like device_session_id" do
+    it "accepts additional security parameters: device_session_id and fraud_merchant_id" do
       result = Braintree::Transaction.create(
         :type => "sale",
         :amount => Braintree::Test::TransactionAmounts::Authorize,
@@ -163,7 +164,8 @@ describe Braintree::Transaction do
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009"
         },
-        :device_session_id => "abc123"
+        :device_session_id => "abc123",
+        :fraud_merchant_id => "7"
       )
 
       result.success?.should == true
@@ -385,6 +387,19 @@ describe Braintree::Transaction do
           Braintree::Configuration.private_key = old_private_key
         end
       end
+
+      it "exposes the fraud gateway rejection reason" do
+        result = Braintree::Transaction.sale(
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Fraud,
+            :expiration_date => "05/2017",
+            :cvv => "333"
+          }
+        )
+        result.success?.should == false
+        result.transaction.gateway_rejection_reason.should == Braintree::Transaction::GatewayRejectionReason::Fraud
+      end
     end
 
     it "accepts credit card expiration month and expiration year" do

data/spec/spec_helper.rb

@@ -1,182 +1,185 @@
-project_root = File.expand_path(File.dirname(__FILE__) + "/..")
-require "rubygems"
-require "libxml"
-
-braintree_lib = "#{project_root}/lib"
-$LOAD_PATH << braintree_lib
-require "braintree"
-
-Braintree::Configuration.environment = :development
-Braintree::Configuration.merchant_id = "integration_merchant_id"
-Braintree::Configuration.public_key = "integration_public_key"
-Braintree::Configuration.private_key = "integration_private_key"
-logger = Logger.new("/dev/null")
-logger.level = Logger::INFO
-Braintree::Configuration.logger = logger
-
-module Kernel
-  alias_method :original_warn, :warn
-  def warn(message)
-    return if message =~ /^\[DEPRECATED\]/
-    original_warn(message)
+unless defined?(SPEC_HELPER_LOADED)
+  SPEC_HELPER_LOADED = true
+  project_root = File.expand_path(File.dirname(__FILE__) + "/..")
+  require "rubygems"
+  require "libxml"
+
+  braintree_lib = "#{project_root}/lib"
+  $LOAD_PATH << braintree_lib
+  require "braintree"
+
+  Braintree::Configuration.environment = :development
+  Braintree::Configuration.merchant_id = "integration_merchant_id"
+  Braintree::Configuration.public_key = "integration_public_key"
+  Braintree::Configuration.private_key = "integration_private_key"
+  logger = Logger.new("/dev/null")
+  logger.level = Logger::INFO
+  Braintree::Configuration.logger = logger
+
+  module Kernel
+    alias_method :original_warn, :warn
+    def warn(message)
+      return if message =~ /^\[DEPRECATED\]/
+      original_warn(message)
+    end
   end
-end
 
-def now_in_eastern
-  (Time.now.utc - 5*60*60).strftime("%Y-%m-%d")
-end
+  def now_in_eastern
+    (Time.now.utc - 5*60*60).strftime("%Y-%m-%d")
+  end
 
-module SpecHelper
-
-  DefaultMerchantAccountId = "sandbox_credit_card"
-  NonDefaultMerchantAccountId = "sandbox_credit_card_non_default"
-  NonDefaultSubMerchantAccountId = "sandbox_sub_merchant_account"
-
-  TrialPlan = {
-    :description => "Plan for integration tests -- with trial",
-    :id => "integration_trial_plan",
-    :price => BigDecimal.new("43.21"),
-    :trial_period => true,
-    :trial_duration => 2,
-    :trial_duration_unit => Braintree::Subscription::TrialDurationUnit::Day
-  }
-
-  TriallessPlan = {
-    :description => "Plan for integration tests -- without a trial",
-    :id => "integration_trialless_plan",
-    :price => BigDecimal.new("12.34"),
-    :trial_period => false
-  }
-
-  AddOnDiscountPlan = {
-    :description => "Plan for integration tests -- with add-ons and discounts",
-    :id => "integration_plan_with_add_ons_and_discounts",
-    :price => BigDecimal.new("9.99"),
-    :trial_period => true,
-    :trial_duration => 2,
-    :trial_duration_unit => Braintree::Subscription::TrialDurationUnit::Day
-  }
-
-  BillingDayOfMonthPlan = {
-    :description => "Plan for integration tests -- with billing day of month",
-    :id => "integration_plan_with_billing_day_of_month",
-    :price => BigDecimal.new("8.88"),
-    :billing_day_of_month => 5
-  }
-
-  AddOnIncrease10 = "increase_10"
-  AddOnIncrease20 = "increase_20"
-  AddOnIncrease30 = "increase_30"
-
-  Discount7 = "discount_7"
-  Discount11 = "discount_11"
-  Discount15 = "discount_15"
-
-  TestMerchantConfig = Braintree::Configuration.new(
-                                                    :logger => Logger.new("/dev/null"),
-                                                    :environment => :development,
-                                                    :merchant_id => "test_merchant_id",
-                                                    :public_key => "test_public_key",
-                                                    :private_key => "test_private_key"
+  module SpecHelper
+
+    DefaultMerchantAccountId = "sandbox_credit_card"
+    NonDefaultMerchantAccountId = "sandbox_credit_card_non_default"
+    NonDefaultSubMerchantAccountId = "sandbox_sub_merchant_account"
+
+    TrialPlan = {
+      :description => "Plan for integration tests -- with trial",
+      :id => "integration_trial_plan",
+      :price => BigDecimal.new("43.21"),
+      :trial_period => true,
+      :trial_duration => 2,
+      :trial_duration_unit => Braintree::Subscription::TrialDurationUnit::Day
+    }
+
+    TriallessPlan = {
+      :description => "Plan for integration tests -- without a trial",
+      :id => "integration_trialless_plan",
+      :price => BigDecimal.new("12.34"),
+      :trial_period => false
+    }
+
+    AddOnDiscountPlan = {
+      :description => "Plan for integration tests -- with add-ons and discounts",
+      :id => "integration_plan_with_add_ons_and_discounts",
+      :price => BigDecimal.new("9.99"),
+      :trial_period => true,
+      :trial_duration => 2,
+      :trial_duration_unit => Braintree::Subscription::TrialDurationUnit::Day
+    }
+
+    BillingDayOfMonthPlan = {
+      :description => "Plan for integration tests -- with billing day of month",
+      :id => "integration_plan_with_billing_day_of_month",
+      :price => BigDecimal.new("8.88"),
+      :billing_day_of_month => 5
+    }
+
+    AddOnIncrease10 = "increase_10"
+    AddOnIncrease20 = "increase_20"
+    AddOnIncrease30 = "increase_30"
+
+    Discount7 = "discount_7"
+    Discount11 = "discount_11"
+    Discount15 = "discount_15"
+
+    TestMerchantConfig = Braintree::Configuration.new(
+                                                      :logger => Logger.new("/dev/null"),
+                                                      :environment => :development,
+                                                      :merchant_id => "test_merchant_id",
+                                                      :public_key => "test_public_key",
+                                                      :private_key => "test_private_key"
+                                                      )
+
+    def self.make_past_due(subscription, number_of_days_past_due = 1)
+      Braintree::Configuration.instantiate.http.put(
+                                                    "/subscriptions/#{subscription.id}/make_past_due?days_past_due=#{number_of_days_past_due}"
                                                     )
+    end
 
-  def self.make_past_due(subscription, number_of_days_past_due = 1)
-    Braintree::Configuration.instantiate.http.put(
-                                                  "/subscriptions/#{subscription.id}/make_past_due?days_past_due=#{number_of_days_past_due}"
-                                                  )
-  end
-
-  def self.settle_transaction(transaction_id)
-    Braintree::Configuration.instantiate.http.put("/transactions/#{transaction_id}/settle")
-  end
+    def self.settle_transaction(transaction_id)
+      Braintree::Configuration.instantiate.http.put("/transactions/#{transaction_id}/settle")
+    end
 
-  def self.stub_time_dot_now(desired_time)
-    Time.class_eval do
-      class << self
-        alias original_now now
+    def self.stub_time_dot_now(desired_time)
+      Time.class_eval do
+        class << self
+          alias original_now now
+        end
       end
-    end
-    (class << Time; self; end).class_eval do
-      define_method(:now) { desired_time }
-    end
-    yield
-  ensure
-    Time.class_eval do
-      class << self
-        alias now original_now
+      (class << Time; self; end).class_eval do
+        define_method(:now) { desired_time }
+      end
+      yield
+    ensure
+      Time.class_eval do
+        class << self
+          alias now original_now
+        end
       end
     end
-  end
 
-  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.instantiate.port) do |http|
-      request = Net::HTTP::Post.new("/" + url.split("/", 4)[3])
-      request.add_field "Content-Type", "application/x-www-form-urlencoded"
-      request.body = Braintree::Util.hash_to_query_string({:tr_data => tr_data_string}.merge(form_data_hash))
-      response = http.request(request)
-    end
-    if response.code.to_i == 303
-      response["Location"].split("?", 2).last
-    else
-      raise "did not receive a valid tr response: #{response.body[0,1000].inspect}"
+    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.instantiate.port) do |http|
+        request = Net::HTTP::Post.new("/" + url.split("/", 4)[3])
+        request.add_field "Content-Type", "application/x-www-form-urlencoded"
+        request.body = Braintree::Util.hash_to_query_string({:tr_data => tr_data_string}.merge(form_data_hash))
+        response = http.request(request)
+      end
+      if response.code.to_i == 303
+        response["Location"].split("?", 2).last
+      else
+        raise "did not receive a valid tr response: #{response.body[0,1000].inspect}"
+      end
     end
-  end
 
-  def self.using_configuration(config = {}, &block)
-    original_values = {}
-    [:merchant_id, :public_key, :private_key].each do |key|
-      if config[key]
-        original_values[key] = Braintree::Configuration.send(key)
-        Braintree::Configuration.send("#{key}=", config[key])
+    def self.using_configuration(config = {}, &block)
+      original_values = {}
+      [:merchant_id, :public_key, :private_key].each do |key|
+        if config[key]
+          original_values[key] = Braintree::Configuration.send(key)
+          Braintree::Configuration.send("#{key}=", config[key])
+        end
       end
-    end
-    begin
-      yield
-    ensure
-      original_values.each do |key, value|
-        Braintree::Configuration.send("#{key}=", value)
+      begin
+        yield
+      ensure
+        original_values.each do |key, value|
+          Braintree::Configuration.send("#{key}=", value)
+        end
       end
     end
   end
-end
 
-module CustomMatchers
-  class ParseTo
-    def initialize(hash)
-      @expected_hash = hash
-    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
+      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
-    end
 
-    def failure_message
-      "xml parsing failed for #{@failed_parser}, expected #{@expected_hash.inspect} but was #{@results.inspect}"
+      def negative_failure_message
+        raise NotImplementedError
+      end
     end
 
-    def negative_failure_message
-      raise NotImplementedError
+    def parse_to(hash)
+      ParseTo.new(hash)
     end
   end
 
-  def parse_to(hash)
-    ParseTo.new(hash)
+  Spec::Runner.configure do |config|
+    config.include CustomMatchers
   end
 end
-
-Spec::Runner.configure do |config|
-  config.include CustomMatchers
-end