braintree 2.3.1 → 2.4.0

data/lib/braintree/address.rb

@@ -6,7 +6,8 @@ module Braintree
     include BaseModule # :nodoc:
 
     attr_reader :company, :country_name, :created_at, :customer_id, :extended_address, :first_name, :id,
-      :last_name, :locality, :postal_code, :region, :street_address, :updated_at
+      :last_name, :locality, :postal_code, :region, :street_address, :updated_at,
+      :country_code_alpha2, :country_code_alpha3, :country_code_numeric
 
     def self.create(attributes)
       Util.verify_keys(_create_signature, attributes)
@@ -99,8 +100,7 @@ module Braintree
     end
 
     def self._create_signature # :nodoc:
-      [:company, :country_name, :customer_id, :extended_address, :first_name,
-        :last_name, :locality, :postal_code, :region, :street_address]
+      _shared_signature + [:customer_id]
     end
 
     def self._determine_customer_id(customer_or_customer_id) # :nodoc:
@@ -111,6 +111,12 @@ module Braintree
       customer_id
     end
 
+    def self._shared_signature # :nodoc:
+      [:company, :country_code_alpha2, :country_code_alpha3, :country_code_numeric,
+        :country_name, :extended_address, :first_name,
+        :last_name, :locality, :postal_code, :region, :street_address]
+    end
+
     def self._new(*args) # :nodoc:
       self.new *args
     end

data/lib/braintree/credit_card.rb

@@ -66,6 +66,10 @@ module Braintree
       return_object_or_raise(:transaction) { credit(token, transaction_attributes) }
     end
 
+    def self.delete(token)
+      Http.delete("/payment_methods/#{token}")
+    end
+
     # Returns a ResourceCollection of expired credit cards.
     def self.expired(options = {})
       response = Http.post("/payment_methods/all/expired_ids")
@@ -152,7 +156,7 @@ module Braintree
     end
 
     def delete
-      Http.delete("/payment_methods/#{token}")
+      CreditCard.delete(token)
     end
 
     # Returns true if this credit card is the customer's default.
@@ -261,7 +265,7 @@ module Braintree
     end
 
     def self._signature(type) # :nodoc:
-      billing_address_params = [:company, :country_name, :extended_address, :first_name, :last_name, :locality, :postal_code, :region, :street_address]
+      billing_address_params = Address._shared_signature
       signature = [
         :cardholder_name, :cvv, :expiration_date, :expiration_month, :expiration_year, :number, :token,
         {:options => [:make_default, :verification_merchant_account_id, :verify_card]},

data/lib/braintree/credit_card_verification.rb

@@ -3,7 +3,8 @@ module Braintree
     include BaseModule
 
     attr_reader :avs_error_response_code, :avs_postal_code_response_code, :avs_street_address_response_code,
-      :cvv_response_code, :merchant_account_id, :processor_response_code, :processor_response_text, :status
+      :cvv_response_code, :merchant_account_id, :processor_response_code, :processor_response_text, :status,
+      :gateway_rejection_reason
 
     def initialize(attributes) # :nodoc:
       set_instance_variables_from_hash(attributes)
@@ -14,7 +15,7 @@ module Braintree
         :status, :processor_response_code, :processor_response_text,
         :cvv_response_code, :avs_error_response_code,
         :avs_postal_code_response_code, :avs_street_address_response_code,
-        :merchant_account_id
+        :merchant_account_id, :gateway_rejection_reason
       ]
       formatted_attrs = attr_order.map do |attr|
         "#{attr}: #{send(attr).inspect}"

data/lib/braintree/error_codes.rb

@@ -7,8 +7,12 @@ module Braintree
       CannotBeBlank = "81801"
       CompanyIsTooLong = "81802"
       CountryNameIsNotAccepted = "91803"
+      CountryCodeAlpha2IsNotAccepted  = "91814"
+      CountryCodeAlpha3IsNotAccepted  = "91816"
+      CountryCodeNumericIsNotAccepted = "91817"
       ExtendedAddressIsTooLong = "81804"
       FirstNameIsTooLong = "81805"
+      InconsistentCountry = "91815"
       LastNameIsTooLong = "81806"
       LocalityIsTooLong = "81807"
       PostalCodeInvalidCharacters = "81813"
@@ -55,18 +59,19 @@ module Braintree
       CustomFieldIsInvalid = "91602"
       CustomFieldIsTooLong = "81603"
       EmailIsInvalid = "81604"
-      EmailIsTooLong = "81605"
       EmailIsRequired = "81606"
+      EmailIsTooLong = "81605"
       FaxIsTooLong = "81607"
       FirstNameIsTooLong = "81608"
       IdIsInUse = "91609"
       IdIsInvaild = "91610"
       IdIsNotAllowed = "91611"
+      IdIsRequired = "91613"
       IdIsTooLong = "91612"
       LastNameIsTooLong = "81613"
       PhoneIsTooLong = "81614"
-      WebsiteIsTooLong = "81615"
       WebsiteIsInvalid = "81616"
+      WebsiteIsTooLong = "81615"
     end
 
     module Subscription

data/lib/braintree/error_result.rb

@@ -17,11 +17,12 @@ module Braintree
   #   end
   class ErrorResult
 
-    attr_reader :credit_card_verification, :transaction, :errors, :params
+    attr_reader :credit_card_verification, :transaction, :errors, :params, :message
 
     def initialize(data) # :nodoc:
       @params = data[:params]
       @credit_card_verification = CreditCardVerification._new(data[:verification]) if data[:verification]
+      @message = data[:message]
       @transaction = Transaction._new(data[:transaction]) if data[:transaction]
       @errors = Errors.new(data[:errors])
     end

data/lib/braintree/transaction.rb

@@ -128,6 +128,13 @@ module Braintree
       Token = 'token'
     end
 
+    module GatewayRejectionReason
+      AVS = "avs"
+      AVS_AND_CVV = "avs_and_cvv"
+      CVV = "cvv"
+      DUPLICATE = "duplicate"
+    end
+
     module Status
       Authorizing = 'authorizing'
       Authorized = 'authorized'
@@ -137,7 +144,6 @@ module Braintree
       Settled = 'settled'
       SettlementFailed = 'settlement_failed'
       SubmittedForSettlement = 'submitted_for_settlement'
-      Unknown = 'unknown'
       Voided = 'voided'
 
       All = constants.map { |c| const_get(c) }
@@ -159,6 +165,7 @@ module Braintree
     attr_reader :currency_iso_code
     attr_reader :custom_fields
     attr_reader :cvv_response_code
+    attr_reader :gateway_rejection_reason
     attr_reader :merchant_account_id
     attr_reader :order_id
     attr_reader :billing_details, :shipping_details
@@ -408,8 +415,12 @@ module Braintree
         :amount, :customer_id, :merchant_account_id, :order_id, :payment_method_token, :type,
         {:credit_card => [:token, :cardholder_name, :cvv, :expiration_date, :expiration_month, :expiration_year, :number]},
         {:customer => [:id, :company, :email, :fax, :first_name, :last_name, :phone, :website]},
-        {:billing => [:first_name, :last_name, :company, :country_name, :extended_address, :locality, :postal_code, :region, :street_address]},
-        {:shipping => [:first_name, :last_name, :company, :country_name, :extended_address, :locality, :postal_code, :region, :street_address]},
+        {
+          :billing => Address._shared_signature
+        },
+        {
+          :shipping => Address._shared_signature
+        },
         {:options => [:store_in_vault, :submit_for_settlement, :add_billing_address_to_payment_method, :store_shipping_address_in_vault]},
         {:custom_fields => :_any_key_}
       ]

data/lib/braintree/transaction/address_details.rb

@@ -5,7 +5,8 @@ module Braintree
 
       attr_reader :id, :first_name, :last_name, :company,
         :street_address, :extended_address, :locality, :region,
-        :postal_code, :country_name
+        :postal_code, :country_code_alpha2, :country_code_alpha3,
+        :country_code_numeric, :country_name
 
       def initialize(attributes)
         set_instance_variables_from_hash attributes unless attributes.nil?

data/lib/braintree/version.rb

@@ -1,8 +1,8 @@
 module Braintree
   module Version
     Major = 2
-    Minor = 3
-    Tiny = 1
+    Minor = 4
+    Tiny = 0
 
     String = "#{Major}.#{Minor}.#{Tiny}"
   end

data/lib/braintree/xml/generator.rb

@@ -8,6 +8,7 @@ module Braintree
         "Bignum"     => "integer",
         "TrueClass"  => "boolean",
         "FalseClass" => "boolean",
+        "Date"       => "datetime",
         "DateTime"   => "datetime",
         "Time"       => "datetime",
       }
@@ -19,7 +20,9 @@ module Braintree
 
       XML_FORMATTING = {
         "symbol"     => Proc.new { |symbol| symbol.to_s },
-        "datetime"   => Proc.new { |time| time.xmlschema },
+        "datetime"   => Proc.new do |date_or_time|
+          date_or_time.respond_to?(:xmlschema) ? date_or_time.xmlschema : date_or_time.to_s
+        end,
         "bigdecimal" => Proc.new do |bigdecimal|
           str = bigdecimal.to_s('F')
           if str =~ /\.\d$/

data/spec/integration/braintree/address_spec.rb

@@ -27,6 +27,65 @@ describe Braintree::Address do
       result.address.region.should == "Illinois"
       result.address.postal_code.should == "60622"
       result.address.country_name.should == "United States of America"
+      result.address.country_code_alpha2.should == "US"
+      result.address.country_code_alpha3.should == "USA"
+      result.address.country_code_numeric.should == "840"
+    end
+
+    it "accepts country_codes" do
+      customer = Braintree::Customer.create!
+      result = Braintree::Address.create(
+        :customer_id => customer.id,
+        :country_code_alpha2 => "AS",
+        :country_code_alpha3 => "ASM",
+        :country_code_numeric => "16"
+      )
+      result.success?.should == true
+      result.address.country_name.should == "American Samoa"
+      result.address.country_code_alpha2.should == "AS"
+      result.address.country_code_alpha3.should == "ASM"
+      result.address.country_code_numeric.should == "016"
+    end
+
+    it "returns an error response given inconsistent country codes" do
+      customer = Braintree::Customer.create!
+      result = Braintree::Address.create(
+        :customer_id => customer.id,
+        :country_code_alpha2 => "AS",
+        :country_code_alpha3 => "USA"
+      )
+      result.success?.should == false
+      result.errors.for(:address).on(:base).map {|e| e.code}.should include(Braintree::ErrorCodes::Address::InconsistentCountry)
+    end
+
+    it "returns an error response given an invalid country_code_alpha2" do
+      customer = Braintree::Customer.create!
+      result = Braintree::Address.create(
+        :customer_id => customer.id,
+        :country_code_alpha2 => "zz"
+      )
+      result.success?.should == false
+      result.errors.for(:address).on(:country_code_alpha2).map {|e| e.code}.should include(Braintree::ErrorCodes::Address::CountryCodeAlpha2IsNotAccepted)
+    end
+
+    it "returns an error response given an invalid country_code_alpha3" do
+      customer = Braintree::Customer.create!
+      result = Braintree::Address.create(
+        :customer_id => customer.id,
+        :country_code_alpha3 => "zzz"
+      )
+      result.success?.should == false
+      result.errors.for(:address).on(:country_code_alpha3).map {|e| e.code}.should include(Braintree::ErrorCodes::Address::CountryCodeAlpha3IsNotAccepted)
+    end
+
+    it "returns an error response given an invalid country_code_numeric" do
+      customer = Braintree::Customer.create!
+      result = Braintree::Address.create(
+        :customer_id => customer.id,
+        :country_code_numeric => "zz"
+      )
+      result.success?.should == false
+      result.errors.for(:address).on(:country_code_numeric).map {|e| e.code}.should include(Braintree::ErrorCodes::Address::CountryCodeNumericIsNotAccepted)
     end
 
     it "returns an error response if invalid" do
@@ -175,6 +234,28 @@ describe Braintree::Address do
       result.address.region.should == "Illinois"
       result.address.postal_code.should == "60621"
       result.address.country_name.should == "United States of America"
+      result.address.country_code_alpha2.should == "US"
+      result.address.country_code_alpha3.should == "USA"
+      result.address.country_code_numeric.should == "840"
+    end
+
+    it "accepts country_codes" do
+      customer = Braintree::Customer.create!(:last_name => "Miller")
+      address = Braintree::Address.create!(
+        :customer_id => customer.id,
+        :country_name => "Angola"
+      )
+      result = Braintree::Address.update(
+        customer.id,
+        address.id,
+        :country_name => "Azerbaijan"
+      )
+
+      result.success?.should == true
+      result.address.country_name.should == "Azerbaijan"
+      result.address.country_code_alpha2.should == "AZ"
+      result.address.country_code_alpha3.should == "AZE"
+      result.address.country_code_numeric.should == "031"
     end
 
     it "returns an error response if invalid" do

data/spec/integration/braintree/credit_card_spec.rb

@@ -1,7 +1,6 @@
 require File.dirname(__FILE__) + "/../spec_helper"
 
 describe Braintree::CreditCard do
-
   describe "self.create" do
     it "throws and ArgumentError if given exipiration_date and any combination of expiration_month and expiration_year" do
       expect do
@@ -76,6 +75,33 @@ describe Braintree::CreditCard do
       result.credit_card_verification.avs_street_address_response_code.should == "I"
     end
 
+    it "exposes the gateway rejection reason on verification" do
+      old_merchant = Braintree::Configuration.merchant_id
+      old_public_key = Braintree::Configuration.public_key
+      old_private_key = Braintree::Configuration.private_key
+
+      begin
+        Braintree::Configuration.merchant_id = "processing_rules_merchant_id"
+        Braintree::Configuration.public_key = "processing_rules_public_key"
+        Braintree::Configuration.private_key = "processing_rules_private_key"
+
+        customer = Braintree::Customer.create!
+        result = Braintree::CreditCard.create(
+          :customer_id => customer.id,
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009",
+          :cvv => "200",
+          :options => {:verify_card => true}
+        )
+        result.success?.should == false
+        result.credit_card_verification.gateway_rejection_reason.should == Braintree::Transaction::GatewayRejectionReason::CVV
+      ensure
+        Braintree::Configuration.merchant_id = old_merchant
+        Braintree::Configuration.public_key = old_public_key
+        Braintree::Configuration.private_key = old_private_key
+      end
+    end
+
     it "allows user to specify merchant account for verification" do
       customer = Braintree::Customer.create!
       result = Braintree::CreditCard.create(
@@ -121,6 +147,42 @@ describe Braintree::CreditCard do
       credit_card.billing_address.street_address.should == "123 Abc Way"
     end
 
+    it "adds credit card with billing using country_code" do
+      customer = Braintree::Customer.create!
+      result = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :number => Braintree::Test::CreditCardNumbers::MasterCard,
+        :expiration_date => "12/2009",
+        :billing_address => {
+          :country_name => "United States of America",
+          :country_code_alpha2 => "US",
+          :country_code_alpha3 => "USA",
+          :country_code_numeric => "840"
+        }
+      )
+      result.success?.should == true
+      credit_card = result.credit_card
+      credit_card.billing_address.country_name.should == "United States of America"
+      credit_card.billing_address.country_code_alpha2.should == "US"
+      credit_card.billing_address.country_code_alpha3.should == "USA"
+      credit_card.billing_address.country_code_numeric.should == "840"
+    end
+
+    it "returns an error when given inconsistent country information" do
+      customer = Braintree::Customer.create!
+      result = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :number => Braintree::Test::CreditCardNumbers::MasterCard,
+        :expiration_date => "12/2009",
+        :billing_address => {
+          :country_name => "Mexico",
+          :country_code_alpha2 => "US"
+        }
+      )
+      result.success?.should == false
+      result.errors.for(:credit_card).for(:billing_address).on(:base).map { |e| e.code }.should include(Braintree::ErrorCodes::Address::InconsistentCountry)
+    end
+
     it "returns an error response if unsuccessful" do
       customer = Braintree::Customer.create!
       result = Braintree::CreditCard.create(
@@ -386,6 +448,33 @@ describe Braintree::CreditCard do
         updated_credit_card.billing_address.street_address.should == "123 Nigeria Ave"
         updated_credit_card.billing_address.id.should == credit_card.billing_address.id
       end
+
+      it "updates the country via codes" do
+        customer = Braintree::Customer.create!
+        credit_card = Braintree::CreditCard.create!(
+          :customer_id => customer.id,
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2012",
+          :billing_address => {
+            :street_address => "123 Nigeria Ave"
+          }
+        )
+        update_result = Braintree::CreditCard.update(credit_card.token,
+          :billing_address => {
+            :country_name => "American Samoa",
+            :country_code_alpha2 => "AS",
+            :country_code_alpha3 => "ASM",
+            :country_code_numeric => "016",
+            :options => {:update_existing => true}
+          }
+        )
+        update_result.success?.should == true
+        updated_credit_card = update_result.credit_card
+        updated_credit_card.billing_address.country_name.should == "American Samoa"
+        updated_credit_card.billing_address.country_code_alpha2.should == "AS"
+        updated_credit_card.billing_address.country_code_alpha3.should == "ASM"
+        updated_credit_card.billing_address.country_code_numeric.should == "016"
+      end
     end
 
     it "can pass expiration_month and expiration_year" do
@@ -425,6 +514,7 @@ describe Braintree::CreditCard do
       )
       update_result.success?.should == false
       update_result.credit_card_verification.status.should == Braintree::Transaction::Status::ProcessorDeclined
+      update_result.credit_card_verification.gateway_rejection_reason.should be_nil
     end
 
     it "can update the billing address" do
@@ -680,6 +770,24 @@ describe Braintree::CreditCard do
     end
   end
 
+  describe "self.delete" do
+    it "deletes the credit card" do
+      customer = Braintree::Customer.create.customer
+      result = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :number => Braintree::Test::CreditCardNumbers::Visa,
+        :expiration_date => "05/2012"
+      )
+
+      result.success?.should == true
+      credit_card = result.credit_card
+      Braintree::CreditCard.delete(credit_card.token).should == true
+      expect do
+        Braintree::CreditCard.find(credit_card.token)
+      end.to raise_error(Braintree::NotFoundError)
+    end
+  end
+
   describe "delete" do
     it "deletes the credit card" do
       customer = Braintree::Customer.create.customer

data/spec/integration/braintree/customer_spec.rb

@@ -159,6 +159,28 @@ describe Braintree::Customer do
       result.customer.addresses[0].country_name.should == "United States of America"
     end
 
+    it "can use any country code" do
+      result = Braintree::Customer.create(
+        :first_name => "James",
+        :last_name => "Conroy",
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => "05/2010",
+          :billing_address => {
+            :country_name => "Comoros",
+            :country_code_alpha2 => "KM",
+            :country_code_alpha3 => "COM",
+            :country_code_numeric => "174"
+          }
+        }
+      )
+      result.success?.should == true
+      result.customer.addresses[0].country_name.should == "Comoros"
+      result.customer.addresses[0].country_code_alpha2.should == "KM"
+      result.customer.addresses[0].country_code_alpha3.should == "COM"
+      result.customer.addresses[0].country_code_numeric.should == "174"
+    end
+
     it "stores custom fields when valid" do
       result = Braintree::Customer.create(
         :first_name => "Bill",
@@ -187,6 +209,72 @@ describe Braintree::Customer do
       result.errors.for(:customer).for(:credit_card).for(:billing_address).on(:country_name)[0].message.should == "Country name is not an accepted country."
     end
 
+    it "returns errors if country codes are inconsistent" do
+      result = Braintree::Customer.create(
+        :first_name => "Olivia",
+        :last_name => "Dupree",
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => "05/2010",
+          :billing_address => {
+            :country_name => "Comoros",
+            :country_code_alpha2 => "US",
+            :country_code_alpha3 => "COM",
+          }
+        }
+      )
+      result.success?.should == false
+      result.errors.for(:customer).for(:credit_card).for(:billing_address).on(:base).map {|e| e.code}.should include(Braintree::ErrorCodes::Address::InconsistentCountry)
+    end
+
+    it "returns an error if country code alpha2 is invalid" do
+      result = Braintree::Customer.create(
+        :first_name => "Melissa",
+        :last_name => "Henderson",
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => "05/2010",
+          :billing_address => {
+            :country_code_alpha2 => "zz",
+          }
+        }
+      )
+      result.success?.should == false
+      result.errors.for(:customer).for(:credit_card).for(:billing_address).on(:country_code_alpha2).map {|e| e.code}.should include(Braintree::ErrorCodes::Address::CountryCodeAlpha2IsNotAccepted)
+    end
+
+    it "returns an error if country code alpha3 is invalid" do
+      result = Braintree::Customer.create(
+        :first_name => "Andrew",
+        :last_name => "Patterson",
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => "05/3010",
+          :billing_address => {
+            :country_code_alpha3 => "zzz",
+          }
+        }
+      )
+      result.success?.should == false
+      result.errors.for(:customer).for(:credit_card).for(:billing_address).on(:country_code_alpha3).map {|e| e.code}.should include(Braintree::ErrorCodes::Address::CountryCodeAlpha3IsNotAccepted)
+    end
+
+    it "returns an error if country code numeric is invalid" do
+      result = Braintree::Customer.create(
+        :first_name => "Steve",
+        :last_name => "Hamlin",
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => "05/3010",
+          :billing_address => {
+            :country_code_numeric => "zzz",
+          }
+        }
+      )
+      result.success?.should == false
+      result.errors.for(:customer).for(:credit_card).for(:billing_address).on(:country_code_numeric).map {|e| e.code}.should include(Braintree::ErrorCodes::Address::CountryCodeNumericIsNotAccepted)
+    end
+
     it "returns errors if custom_fields are not registered" do
       result = Braintree::Customer.create(
         :first_name => "Jack",
@@ -571,6 +659,33 @@ describe Braintree::Customer do
       result.customer.custom_fields[:store_me].should == "a value"
     end
 
+    it "can use any country code" do
+      customer = Braintree::Customer.create!(
+        :first_name => "Alex",
+        :last_name => "Matterson"
+      )
+      result = Braintree::Customer.update(
+        customer.id,
+        :first_name => "Sammy",
+        :last_name => "Banderton",
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => "05/2010",
+          :billing_address => {
+            :country_name => "Fiji",
+            :country_code_alpha2 => "FJ",
+            :country_code_alpha3 => "FJI",
+            :country_code_numeric => "242"
+          }
+        }
+      )
+      result.success?.should == true
+      result.customer.addresses[0].country_name.should == "Fiji"
+      result.customer.addresses[0].country_code_alpha2.should == "FJ"
+      result.customer.addresses[0].country_code_alpha3.should == "FJI"
+      result.customer.addresses[0].country_code_numeric.should == "242"
+    end
+
     it "can update the customer, credit card, and billing address in one request" do
       customer = Braintree::Customer.create!(
         :first_name => "Joe",

data/spec/integration/braintree/subscription_spec.rb

@@ -131,6 +131,17 @@ describe Braintree::Subscription do
           result.subscription.trial_period.should == false
         end
 
+        it "doesn't create a transaction if there's a trial period" do
+          result = Braintree::Subscription.create(
+            :payment_method_token => @credit_card.token,
+            :plan_id => TrialPlan[:id]
+          )
+
+          result.subscription.transactions.size.should == 0
+        end
+      end
+
+      context "no trial period" do
         it "creates a transaction if no trial period" do
           result = Braintree::Subscription.create(
             :payment_method_token => @credit_card.token,
@@ -144,13 +155,16 @@ describe Braintree::Subscription do
           result.subscription.transactions.first.subscription_id.should == result.subscription.id
         end
 
-        it "doesn't create a transaction if there's a trial period" do
+        it "does not create the subscription and returns the transaction if the transaction is not successful" do
           result = Braintree::Subscription.create(
             :payment_method_token => @credit_card.token,
-            :plan_id => TrialPlan[:id]
+            :plan_id => TriallessPlan[:id],
+            :price => Braintree::Test::TransactionAmounts::Decline
           )
 
-          result.subscription.transactions.size.should == 0
+          result.success?.should be_false
+          result.transaction.status.should == Braintree::Transaction::Status::ProcessorDeclined
+          result.message.should == "Do Not Honor"
         end
       end
 
@@ -227,7 +241,6 @@ describe Braintree::Subscription do
         result.success?.should == false
         result.errors.for(:subscription).on(:trial_duration_unit)[0].message.should == "Trial Duration Unit is invalid."
       end
-
     end
   end
 

data/spec/integration/braintree/transaction_search_spec.rb

@@ -508,103 +508,126 @@ describe Braintree::Transaction, "search" do
         end
       end
 
-      it "searches on created_at in UTC" do
-        transaction = Braintree::Transaction.sale!(
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/12"
-        }
-        )
+      context "created_at" do
+        it "searches on created_at in UTC" do
+          transaction = Braintree::Transaction.sale!(
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/12"
+          }
+          )
 
-        created_at = transaction.created_at
-        created_at.should be_utc
+          created_at = transaction.created_at
+          created_at.should be_utc
 
-        collection = Braintree::Transaction.search do |search|
-          search.id.is transaction.id
-          search.created_at.between(
-            created_at - 60,
-            created_at + 60
-          )
-        end
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction.id
+            search.created_at.between(
+              created_at - 60,
+              created_at + 60
+            )
+          end
 
-        collection.maximum_size.should == 1
-        collection.first.id.should == transaction.id
+          collection.maximum_size.should == 1
+          collection.first.id.should == transaction.id
 
-        collection = Braintree::Transaction.search do |search|
-          search.id.is transaction.id
-          search.created_at >= created_at - 1
-        end
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction.id
+            search.created_at >= created_at - 1
+          end
 
-        collection.maximum_size.should == 1
-        collection.first.id.should == transaction.id
+          collection.maximum_size.should == 1
+          collection.first.id.should == transaction.id
 
-        collection = Braintree::Transaction.search do |search|
-          search.id.is transaction.id
-          search.created_at <= created_at + 1
-        end
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction.id
+            search.created_at <= created_at + 1
+          end
 
-        collection.maximum_size.should == 1
-        collection.first.id.should == transaction.id
+          collection.maximum_size.should == 1
+          collection.first.id.should == transaction.id
 
-        collection = Braintree::Transaction.search do |search|
-          search.id.is transaction.id
-          search.created_at.between(
-            created_at - 300,
-            created_at - 100
-          )
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction.id
+            search.created_at.between(
+              created_at - 300,
+              created_at - 100
+            )
+          end
+
+          collection.maximum_size.should == 0
         end
 
-        collection.maximum_size.should == 0
-      end
+        it "searches on created_at in local time" do
+          transaction = Braintree::Transaction.sale!(
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/12"
+          }
+          )
 
-      it "searches on created_at in local time" do
-        transaction = Braintree::Transaction.sale!(
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/12"
-        }
-        )
+          now = Time.now
 
-        now = Time.now
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction.id
+            search.created_at.between(
+              now - 60,
+              now + 60
+            )
+          end
 
-        collection = Braintree::Transaction.search do |search|
-          search.id.is transaction.id
-          search.created_at.between(
-            now - 60,
-            now + 60
-          )
-        end
+          collection.maximum_size.should == 1
+          collection.first.id.should == transaction.id
 
-        collection.maximum_size.should == 1
-        collection.first.id.should == transaction.id
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction.id
+            search.created_at >= now - 60
+          end
 
-        collection = Braintree::Transaction.search do |search|
-          search.id.is transaction.id
-          search.created_at >= now - 60
-        end
+          collection.maximum_size.should == 1
+          collection.first.id.should == transaction.id
 
-        collection.maximum_size.should == 1
-        collection.first.id.should == transaction.id
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction.id
+            search.created_at <= now + 60
+          end
 
-        collection = Braintree::Transaction.search do |search|
-          search.id.is transaction.id
-          search.created_at <= now + 60
-        end
+          collection.maximum_size.should == 1
+          collection.first.id.should == transaction.id
 
-        collection.maximum_size.should == 1
-        collection.first.id.should == transaction.id
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction.id
+            search.created_at.between(
+              now - 300,
+              now - 100
+            )
+          end
 
-        collection = Braintree::Transaction.search do |search|
-          search.id.is transaction.id
-          search.created_at.between(
-            now - 300,
-            now - 100
-          )
+          collection.maximum_size.should == 0
         end
 
-        collection.maximum_size.should == 0
+        it "searches on created_at with dates" do
+          transaction = Braintree::Transaction.sale!(
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/12"
+          }
+          )
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction.id
+            search.created_at.between(
+              Date.today - 1,
+              Date.today + 1
+            )
+          end
+
+          collection.maximum_size.should == 1
+          collection.first.id.should == transaction.id
+        end
       end
     end
 

data/spec/integration/braintree/transaction_spec.rb

@@ -39,6 +39,207 @@ describe Braintree::Transaction do
       result.transaction.processor_response_text.should == "Do Not Honor"
     end
 
+    it "accepts all four country codes" do
+      result = Braintree::Transaction.sale(
+        :amount => "100",
+        :customer => {
+          :last_name => "Adama",
+        },
+        :credit_card => {
+          :number => "5105105105105100",
+          :expiration_date => "05/2012"
+        },
+        :billing => {
+          :country_name => "Botswana",
+          :country_code_alpha2 => "BW",
+          :country_code_alpha3 => "BWA",
+          :country_code_numeric => "072"
+        },
+        :shipping => {
+          :country_name => "Bhutan",
+          :country_code_alpha2 => "BT",
+          :country_code_alpha3 => "BTN",
+          :country_code_numeric => "064"
+        },
+        :options => {
+          :add_billing_address_to_payment_method => true,
+          :store_in_vault => true
+        }
+      )
+      result.success?.should == true
+      transaction = result.transaction
+      transaction.billing_details.country_name.should == "Botswana"
+      transaction.billing_details.country_code_alpha2.should == "BW"
+      transaction.billing_details.country_code_alpha3.should == "BWA"
+      transaction.billing_details.country_code_numeric.should == "072"
+
+      transaction.shipping_details.country_name.should == "Bhutan"
+      transaction.shipping_details.country_code_alpha2.should == "BT"
+      transaction.shipping_details.country_code_alpha3.should == "BTN"
+      transaction.shipping_details.country_code_numeric.should == "064"
+
+      transaction.vault_credit_card.billing_address.country_name.should == "Botswana"
+      transaction.vault_credit_card.billing_address.country_code_alpha2.should == "BW"
+      transaction.vault_credit_card.billing_address.country_code_alpha3.should == "BWA"
+      transaction.vault_credit_card.billing_address.country_code_numeric.should == "072"
+    end
+
+    it "returns an error if provided inconsistent country information" do
+      result = Braintree::Transaction.sale(
+        :amount => "100",
+        :credit_card => {
+          :number => "5105105105105100",
+          :expiration_date => "05/2012"
+        },
+        :billing => {
+          :country_name => "Botswana",
+          :country_code_alpha2 => "US",
+        }
+      )
+
+      result.success?.should == false
+      result.errors.for(:transaction).for(:billing).on(:base).map { |e| e.code }.should include(Braintree::ErrorCodes::Address::InconsistentCountry)
+    end
+
+    it "returns an error if given an incorrect alpha2 code" do
+      result = Braintree::Transaction.sale(
+        :amount => "100",
+        :credit_card => {
+          :number => "5105105105105100",
+          :expiration_date => "05/2012"
+        },
+        :billing => {
+          :country_code_alpha2 => "ZZ"
+        }
+      )
+
+      result.success?.should == false
+      codes = result.errors.for(:transaction).for(:billing).on(:country_code_alpha2).map { |e| e.code }
+      codes.should include(Braintree::ErrorCodes::Address::CountryCodeAlpha2IsNotAccepted)
+    end
+
+    it "returns an error if given an incorrect alpha3 code" do
+      result = Braintree::Transaction.sale(
+        :amount => "100",
+        :credit_card => {
+          :number => "5105105105105100",
+          :expiration_date => "05/2012"
+        },
+        :billing => {
+          :country_code_alpha3 => "ZZZ"
+        }
+      )
+
+      result.success?.should == false
+      codes = result.errors.for(:transaction).for(:billing).on(:country_code_alpha3).map { |e| e.code }
+      codes.should include(Braintree::ErrorCodes::Address::CountryCodeAlpha3IsNotAccepted)
+    end
+
+    it "returns an error if given an incorrect numeric code" do
+      result = Braintree::Transaction.sale(
+        :amount => "100",
+        :credit_card => {
+          :number => "5105105105105100",
+          :expiration_date => "05/2012"
+        },
+        :billing => {
+          :country_code_numeric => "FOO"
+        }
+      )
+
+      result.success?.should == false
+      codes = result.errors.for(:transaction).for(:billing).on(:country_code_numeric).map { |e| e.code }
+      codes.should include(Braintree::ErrorCodes::Address::CountryCodeNumericIsNotAccepted)
+    end
+
+    context "gateway rejection reason" do
+      it "exposes the cvv gateway rejection reason" do
+        old_merchant = Braintree::Configuration.merchant_id
+        old_public_key = Braintree::Configuration.public_key
+        old_private_key = Braintree::Configuration.private_key
+
+        begin
+          Braintree::Configuration.merchant_id = "processing_rules_merchant_id"
+          Braintree::Configuration.public_key = "processing_rules_public_key"
+          Braintree::Configuration.private_key = "processing_rules_private_key"
+
+          result = Braintree::Transaction.sale(
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/2009",
+              :cvv => "200"
+            }
+          )
+          result.success?.should == false
+          result.transaction.gateway_rejection_reason.should == Braintree::Transaction::GatewayRejectionReason::CVV
+        ensure
+          Braintree::Configuration.merchant_id = old_merchant
+          Braintree::Configuration.public_key = old_public_key
+          Braintree::Configuration.private_key = old_private_key
+        end
+      end
+
+      it "exposes the avs gateway rejection reason" do
+        old_merchant = Braintree::Configuration.merchant_id
+        old_public_key = Braintree::Configuration.public_key
+        old_private_key = Braintree::Configuration.private_key
+
+        begin
+          Braintree::Configuration.merchant_id = "processing_rules_merchant_id"
+          Braintree::Configuration.public_key = "processing_rules_public_key"
+          Braintree::Configuration.private_key = "processing_rules_private_key"
+
+          result = Braintree::Transaction.sale(
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :billing => {
+              :street_address => "200 Fake Street"
+            },
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/2009"
+            }
+          )
+          result.success?.should == false
+          result.transaction.gateway_rejection_reason.should == Braintree::Transaction::GatewayRejectionReason::AVS
+        ensure
+          Braintree::Configuration.merchant_id = old_merchant
+          Braintree::Configuration.public_key = old_public_key
+          Braintree::Configuration.private_key = old_private_key
+        end
+      end
+
+      it "exposes the avs_and_cvv gateway rejection reason" do
+        old_merchant = Braintree::Configuration.merchant_id
+        old_public_key = Braintree::Configuration.public_key
+        old_private_key = Braintree::Configuration.private_key
+
+        begin
+          Braintree::Configuration.merchant_id = "processing_rules_merchant_id"
+          Braintree::Configuration.public_key = "processing_rules_public_key"
+          Braintree::Configuration.private_key = "processing_rules_private_key"
+
+          result = Braintree::Transaction.sale(
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :billing => {
+              :postal_code => "20000"
+            },
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/2009",
+              :cvv => "200"
+            }
+          )
+          result.success?.should == false
+          result.transaction.gateway_rejection_reason.should == Braintree::Transaction::GatewayRejectionReason::AVS_AND_CVV
+        ensure
+          Braintree::Configuration.merchant_id = old_merchant
+          Braintree::Configuration.public_key = old_public_key
+          Braintree::Configuration.private_key = old_private_key
+        end
+      end
+    end
+
     it "accepts credit card expiration month and expiration year" do
       result = Braintree::Transaction.create(
         :type => "sale",
@@ -63,6 +264,7 @@ describe Braintree::Transaction do
       )
       result.success?.should == false
       result.errors.for(:transaction).on(:customer_id)[0].code.should == "91510"
+      result.message.should == "Customer ID is invalid."
     end
 
     it "can create custom fields" do
@@ -374,6 +576,9 @@ describe Braintree::Transaction do
       transaction.billing_details.region.should == "IL"
       transaction.billing_details.postal_code.should == "60622"
       transaction.billing_details.country_name.should == "United States of America"
+      transaction.billing_details.country_code_alpha2.should == "US"
+      transaction.billing_details.country_code_alpha3.should == "USA"
+      transaction.billing_details.country_code_numeric.should == "840"
       transaction.shipping_details.first_name.should == "Andrew"
       transaction.shipping_details.last_name.should == "Mason"
       transaction.shipping_details.company.should == "Braintree"
@@ -383,6 +588,9 @@ describe Braintree::Transaction do
       transaction.shipping_details.region.should == "IL"
       transaction.shipping_details.postal_code.should == "60103"
       transaction.shipping_details.country_name.should == "United States of America"
+      transaction.shipping_details.country_code_alpha2.should == "US"
+      transaction.shipping_details.country_code_alpha3.should == "USA"
+      transaction.shipping_details.country_code_numeric.should == "840"
     end
 
     it "allows merchant account to be specified" do

data/spec/unit/braintree/credit_card_spec.rb

@@ -22,6 +22,9 @@ describe Braintree::CreditCard do
         {:options => [:make_default, :verification_merchant_account_id, :verify_card]},
         {:billing_address => [
           :company,
+          :country_code_alpha2,
+          :country_code_alpha3,
+          :country_code_numeric,
           :country_name,
           :extended_address,
           :first_name,
@@ -49,6 +52,9 @@ describe Braintree::CreditCard do
         {:options => [:make_default, :verification_merchant_account_id, :verify_card]},
         {:billing_address => [
           :company,
+          :country_code_alpha2,
+          :country_code_alpha3,
+          :country_code_numeric,
           :country_name,
           :extended_address,
           :first_name,

data/spec/unit/braintree/credit_card_verification_spec.rb

@@ -13,7 +13,7 @@ describe Braintree::CreditCardVerification do
         :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", 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", merchant_account_id: "some_id", gateway_rejection_reason: nil>)
     end
   end
 end

data/spec/unit/braintree/customer_spec.rb

@@ -70,6 +70,9 @@ describe Braintree::Customer do
           {:options => [:make_default, :verification_merchant_account_id, :verify_card]},
           {:billing_address => [
             :company,
+            :country_code_alpha2,
+            :country_code_alpha3,
+            :country_code_numeric,
             :country_name,
             :extended_address,
             :first_name,
@@ -112,6 +115,9 @@ describe Braintree::Customer do
           ]},
           {:billing_address => [
             :company,
+            :country_code_alpha2,
+            :country_code_alpha3,
+            :country_code_numeric,
             :country_name,
             :extended_address,
             :first_name,

data/spec/unit/braintree/error_result_spec.rb

@@ -2,25 +2,10 @@ require File.dirname(__FILE__) + "/../spec_helper"
 
 describe Braintree::ErrorResult do
   describe "initialize" do
-    it "initializes params and errors" do
-      errors = {
-        :scope => {
-          :errors => [{:code => "123", :message => "something is invalid", :attribute => "something"}]
-        }
-      }
-      result = Braintree::ErrorResult.new(:params => "params", :errors => errors)
-      result.success?.should == false
-      result.params.should == "params"
-      result.errors.size.should == 1
-      result.errors.for(:scope)[0].message.should == "something is invalid"
-      result.errors.for(:scope)[0].attribute.should == "something"
-      result.errors.for(:scope)[0].code.should == "123"
-    end
-
-    it "ignores data other than params and errors" do
+    it "ignores data other than params, errors, and message" do
       # so that we can add more data into the response in the future without breaking the client lib
       expect do
-        result = Braintree::ErrorResult.new(:params => "params", :errors => {:errors => []}, :extra => "is ignored")
+        result = Braintree::ErrorResult.new(:params => "params", :errors => {:errors => []}, :extra => "is ignored", :message => "foo bar")
       end.to_not raise_error
     end
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: braintree
 version: !ruby/object:Gem::Version 
-  hash: 1
+  hash: 31
   prerelease: false
   segments: 
   - 2
-  - 3
-  - 1
-  version: 2.3.1
+  - 4
+  - 0
+  version: 2.4.0
 platform: ruby
 authors: 
 - Braintree Payment Solutions
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-24 00:00:00 -05:00
+date: 2010-07-09 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency