braintree 1.0.0 → 1.0.1

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Braintree Payment Solutions
+Copyright (c) 2009-2010 Braintree Payment Solutions
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

data/lib/braintree/configuration.rb

@@ -58,7 +58,7 @@ module Braintree
     def self.port # :nodoc:
       case environment
       when :development
-        3000
+        ENV['GATEWAY_PORT'] || 3000
       when :production, :qa, :sandbox
         443
       end

data/lib/braintree/customer.rb

@@ -3,7 +3,7 @@ module Braintree
     include BaseModule
     
     attr_reader :addresses, :company, :created_at, :credit_cards, :email, :fax, :first_name, :id, :last_name,
-      :phone, :updated_at, :website
+      :phone, :updated_at, :website, :custom_fields
   
     # Returns a PagedCollection of all customers stored in the vault. Due to race conditions, this method
     # may not reliably return all customers stored in the vault.
@@ -92,6 +92,17 @@ module Braintree
     def self.sale!(customer_id, transaction_attributes)
        return_object_or_raise(:transaction){ sale(customer_id, transaction_attributes) }
     end
+
+    # Returns a PagedCollection of transactions for the customer with the given +customer_id+.
+    def self.transactions(customer_id, options = {})
+      page_number = options[:page] || 1
+      response = Http.get "/customers/#{customer_id}/transactions?page=#{page_number}"
+      attributes = response[:credit_card_transactions]
+      attributes[:items] = Util.extract_attribute_as_array(attributes, :transaction).map do |transaction_attributes|
+        Transaction._new transaction_attributes
+      end
+      PagedCollection.new(attributes) { |page_number| Customer.transactions(customer_id, :page => page_number) }
+    end
     
     def self.update(customer_id, attributes)
       Util.verify_keys(_update_signature, attributes)
@@ -118,7 +129,7 @@ module Braintree
     end
     
     def credit(transaction_attributes)
-      Customer.credit(self.id, transaction_attributes)
+      Customer.credit(id, transaction_attributes)
     end
     
     def credit!(transaction_attributes)
@@ -140,22 +151,16 @@ module Braintree
     end
     
     def sale(transaction_attributes)
-      Customer.sale(self.id, transaction_attributes)
+      Customer.sale(id, transaction_attributes)
     end
     
     def sale!(transaction_attributes)
       return_object_or_raise(:transaction) { sale(transaction_attributes) }
     end
 
-    # Finds transactions associated to the customer. Returns a PagedCollection.
+    # Returns a PagedCollection of transactions for the customer.
     def transactions(options = {})
-      page_number = options[:page] || 1
-      response = Http.get "/customers/#{id}/transactions?page=#{page_number}"
-      attributes = response[:credit_card_transactions]
-      attributes[:items] = Util.extract_attribute_as_array(attributes, :transaction).map do |transaction_attributes|
-        Transaction._new transaction_attributes
-      end
-      PagedCollection.new(attributes) { |page_number| self.transactions(:page => page_number) }
+      Customer.transactions(id, options)
     end
 
     def update(attributes)
@@ -194,7 +199,8 @@ module Braintree
       credit_card_signature = CreditCard._create_signature - [:customer_id]
       [
         :company, :email, :fax, :first_name, :id, :last_name, :phone, :website,
-        {:credit_card => credit_card_signature}
+        {:credit_card => credit_card_signature},
+        {:custom_fields => :_any_key_}
       ]
     end
 
@@ -225,7 +231,7 @@ module Braintree
     end  
 
     def self._update_signature # :nodoc:
-      [ :company, :email, :fax, :first_name, :id, :last_name, :phone, :website ]
+      [ :company, :email, :fax, :first_name, :id, :last_name, :phone, :website, {:custom_fields => :_any_key_} ]
     end
   end
 end

data/lib/braintree/error_codes.rb

@@ -21,6 +21,7 @@ module Braintree
     module CreditCard
       BillingAddressConflict = "91701"
       BillingAddressIdIsInvalid = "91702"
+      CardholderNameIsTooLong = "81723"
       CreditCardTypeIsNotAccepted = "81703"
       CustomerIdIsRequired = "91704"
       CustomerIdIsInvalid = "91705"
@@ -77,12 +78,11 @@ module Braintree
       HasAlreadyBeenRefunded = "91512"
       MerchantAccountNameIsInvalid = "91513"
       MerchantAccountIsSuspended = "91514"
+      OrderIdIsTooLong = "91501"
       PaymentMethodConflict = "91515"
       PaymentMethodDoesNotBelongToCustomer = "91516"
       PaymentMethodTokenCardTypeIsNotAccepted = "91517"
       PaymentMethodTokenIsInvalid = "91518"
-      ProcessorAuthorizationCodeCannotBeSet = "91519"
-      ProcessorAuthorizationCodeIsInvalid = "81520"
       RefundAmountIsTooLarge = "91521"
       SettlementAmountIsTooLarge = "91522"
       TypeIsInvalid = "91523"

data/lib/braintree/transaction.rb

@@ -55,6 +55,9 @@ module Braintree
   #      :region => "IL",
   #      :postal_code => "60103",
   #      :country_name => "United States of America"
+  #    },
+  #    :custom_fields => {
+  #      :birthdate => "11/13/1954"
   #    }
   #  )
   #
@@ -64,7 +67,7 @@ module Braintree
   # a transaction can be stored in the vault by setting
   # <tt>transaction[options][store_in_vault]</tt> to true.
   #
-  #   transaction = Braintree::Transaction.create!(
+  #   transaction = Braintree::Transaction.sale!(
   #     :customer => {
   #       :first_name => "Adam",
   #       :last_name => "Williams"
@@ -82,6 +85,17 @@ module Braintree
   #   transaction.credit_card_details.token
   #   # => "6b6m"
   #
+  # To also store the billing address in the vault, pass the
+  # +add_billing_address_to_payment_method+ option.
+  #
+  #   Braintree::Transaction.sale!(
+  #     # ...
+  #     :options => {
+  #       :store_in_vault => true
+  #       :add_billing_address_to_payment_method => true
+  #     }
+  #   )
+  #
   # == Submitting for Settlement
   #
   # This can only be done when the transction's
@@ -112,8 +126,10 @@ module Braintree
     
     attr_reader :avs_error_response_code, :avs_postal_code_response_code, :avs_street_address_response_code
     attr_reader :amount, :created_at, :credit_card_details, :customer_details, :id, :status
+    attr_reader :custom_fields
     attr_reader :order_id
     attr_reader :billing_details, :shipping_details
+    attr_reader :status_history
     # The response code from the processor.
     attr_reader :processor_response_code
     # Will either be "sale" or "credit"
@@ -345,7 +361,8 @@ module Braintree
         {: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]},
-        {:options => [:store_in_vault, :submit_for_settlement]}
+        {:options => [:store_in_vault, :submit_for_settlement, :add_billing_address_to_payment_method]},
+        {:custom_fields => :_any_key_}
       ]
     end
     
@@ -355,6 +372,7 @@ module Braintree
       @customer_details = CustomerDetails.new(@customer)
       @billing_details = AddressDetails.new(@billing)
       @shipping_details = AddressDetails.new(@shipping)
+      @status_history = attributes[:status_history] ? attributes[:status_history].map { |s| StatusDetails.new(s) } : []
     end
-  end  
+  end
 end

data/lib/braintree/transaction/status_details.rb

@@ -0,0 +1,13 @@
+module Braintree
+  class Transaction
+    class StatusDetails # :nodoc:
+      include BaseModule
+      
+      attr_reader :amount, :status, :timestamp, :transaction_source, :user
+
+      def initialize(attributes)
+        set_instance_variables_from_hash attributes unless attributes.nil?
+      end
+    end
+  end
+end

data/lib/braintree/util.rb

@@ -59,7 +59,9 @@ module Braintree
     end
     
     def self.verify_keys(valid_keys, hash)
-      invalid_keys = _flatten_hash_keys(hash) - _flatten_valid_keys(valid_keys)
+      flattened_valid_keys = _flatten_valid_keys(valid_keys)
+      invalid_keys = _flatten_hash_keys(hash) - flattened_valid_keys
+      invalid_keys = _remove_wildcard_keys(flattened_valid_keys, invalid_keys)
       if invalid_keys.any?
         sorted = invalid_keys.sort_by { |k| k.to_s }.join(", ")
         raise ArgumentError, "invalid keys: #{sorted}"
@@ -71,7 +73,12 @@ module Braintree
         if key.is_a?(Hash)
           full_key = key.keys[0]
           full_key = (namespace ? "#{namespace}[#{full_key}]" : full_key)
-          result += _flatten_valid_keys(key.values[0], full_key)
+          nested_keys = key.values[0]
+          if nested_keys.is_a?(Array)
+            result += _flatten_valid_keys(nested_keys, full_key)
+          else
+            result << "#{full_key}[#{nested_keys}]"
+          end
         else
           result << (namespace ? "#{namespace}[#{key}]" : key.to_s)
         end
@@ -90,5 +97,16 @@ module Braintree
         result
       end.sort
     end
+
+    def self._remove_wildcard_keys(valid_keys, invalid_keys)
+      wildcard_keys = valid_keys.select { |k| k.include? "[_any_key_]" }
+      return invalid_keys if wildcard_keys.empty?
+      wildcard_keys.map! { |wk| wk.sub "[_any_key_]", "" }
+      invalid_keys.select do |invalid_key|
+        wildcard_keys.all? do |wildcard_key|
+          invalid_key.index(wildcard_key) != 0
+        end
+      end
+    end
   end
 end

data/lib/braintree/version.rb

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

data/spec/hacks/tcp_socket.rb

@@ -0,0 +1,18 @@
+require 'timeout'
+require 'socket'
+
+TCPSocket.class_eval do
+  def self.wait_for_service(options)
+    Timeout::timeout(options[:timeout] || 20) do
+      loop do
+        begin
+          socket = TCPSocket.new(options[:host], options[:port])
+          socket.close
+          return
+        rescue Errno::ECONNREFUSED
+          sleep 0.5
+        end
+      end
+    end
+  end
+end

data/spec/integration/braintree/credit_card_spec.rb

@@ -644,7 +644,7 @@ describe Braintree::CreditCard do
   
   def create_credit_card_via_tr(regular_params, tr_params = {})
     response = nil
-    Net::HTTP.start("localhost", 3000) do |http|
+    Net::HTTP.start("localhost", Braintree::Configuration.port) do |http|
       request = Net::HTTP::Post.new("/" + Braintree::CreditCard.create_credit_card_url.split("/", 4)[3])
       request.add_field "Content-Type", "application/x-www-form-urlencoded"
       tr_data = Braintree::TransparentRedirect.create_credit_card_data({:redirect_url => "http://example.com"}.merge(tr_params))
@@ -660,7 +660,7 @@ describe Braintree::CreditCard do
 
   def update_credit_card_via_tr(regular_params, tr_params = {})
     response = nil
-    Net::HTTP.start("localhost", 3000) do |http|
+    Net::HTTP.start("localhost", Braintree::Configuration.port) do |http|
       request = Net::HTTP::Post.new("/" + Braintree::CreditCard.update_credit_card_url.split("/", 4)[3])
       request.add_field "Content-Type", "application/x-www-form-urlencoded"
       tr_data = Braintree::TransparentRedirect.update_credit_card_data({:redirect_url => "http://example.com"}.merge(tr_params))

data/spec/integration/braintree/customer_spec.rb

@@ -134,6 +134,18 @@ describe Braintree::Customer do
       result.customer.addresses[0].country_name.should == "United States of America"
     end
     
+    it "stores custom fields when valid" do
+      result = Braintree::Customer.create(
+        :first_name => "Bill",
+        :last_name => "Gates",
+        :custom_fields => {
+          :store_me => "custom value"
+        }
+      )
+      result.success?.should == true
+      result.customer.custom_fields[:store_me].should == "custom value"
+    end
+
     it "returns nested errors if credit card and/or billing address are invalid" do
       result = Braintree::Customer.create(
         :email => "invalid",
@@ -149,6 +161,18 @@ describe Braintree::Customer do
       result.errors.for(:customer).for(:credit_card).on(:number)[0].message.should == "Credit card number is invalid."
       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 custom_fields are not registered" do
+      result = Braintree::Customer.create(
+        :first_name => "Jack",
+        :last_name => "Kennedy",
+        :custom_fields => {
+          :spouse_name => "Jacqueline"
+        }
+      )
+      result.success?.should == false
+      result.errors.for(:customer).on(:custom_fields)[0].message.should == "Custom field is invalid: spouse_name."
+    end
   end
   
   describe "self.create!" do
@@ -252,6 +276,22 @@ describe Braintree::Customer do
     end
   end
 
+  describe "self.transactions" do
+    it "finds transactions for the given customer id" do
+      customer = Braintree::Customer.create!(
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2010"
+        }
+      )
+      transaction = customer.sale!(:amount => "100.00")
+      collection = Braintree::Customer.transactions(customer.id)
+      collection.current_page_number.should == 1
+      collection.total_items.should == 1
+      collection[0].should == transaction
+    end
+  end
+
 
   describe "sale" do
     it "creates a sale transaction using the customer, returning a result object" do
@@ -453,14 +493,18 @@ describe Braintree::Customer do
       result = Braintree::Customer.update(
         customer.id,
         :first_name => "Mr. Joe",
-        :last_name => "Super Cool"
+        :last_name => "Super Cool",
+        :custom_fields => {
+          :store_me => "a value"
+        }
       )
       result.success?.should == true
       result.customer.id.should == customer.id
       result.customer.first_name.should == "Mr. Joe"
       result.customer.last_name.should == "Super Cool"
+      result.customer.custom_fields[:store_me].should == "a value"
     end
-    
+
     it "returns an error response if invalid" do
       customer = Braintree::Customer.create!(:email => "valid@email.com")
       result = Braintree::Customer.update(

data/spec/integration/braintree/error_codes_spec.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Braintree::ErrorCodes do
+  describe Braintree::ErrorCodes::CreditCard do
+    it "returns CardholderNameIsTooLong when cardholder name is too long" do
+      result = Braintree::Customer.create(
+        :credit_card => {
+          :cardholder_name => "x" * 256
+        }
+      )
+      result.success?.should == false
+      result.errors.for(:customer).for(:credit_card).map { |e| e.code }.should \
+        include(Braintree::ErrorCodes::CreditCard::CardholderNameIsTooLong)
+    end
+  end
+end

data/spec/integration/braintree/transaction_spec.rb

@@ -20,7 +20,39 @@ describe Braintree::Transaction do
       result.transaction.credit_card_details.expiration_date.should == "05/2009"
     end
     
-    it "returns an error result if validations fail" do
+    it "can create custom fields" do
+      result = Braintree::Transaction.create(
+        :type => "sale",
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        },
+        :custom_fields => {
+          :store_me => "custom value"
+        }
+      )
+      result.success?.should == true
+      result.transaction.custom_fields.should == {:store_me => "custom value"}
+    end
+
+    it "returns an error if custom_field is not registered" do
+      result = Braintree::Transaction.create(
+        :type => "sale",
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        },
+        :custom_fields => {
+          :invalid_key => "custom value"
+        }
+      )
+      result.success?.should == false
+      result.errors.for(:transaction).on(:custom_fields)[0].message.should == "Custom field is invalid: invalid_key."
+    end
+
+    it "returns the given params if validations fail" do
       params = {
         :transaction => {
           :type => "sale",
@@ -34,7 +66,94 @@ describe Braintree::Transaction do
       result = Braintree::Transaction.create(params[:transaction])
       result.success?.should == false
       result.params.should == {:transaction => {:type => 'sale', :amount => nil, :credit_card => {:expiration_date => "05/2009"}}}
-      result.errors.for(:transaction).on(:amount)[0].message.should == "Amount is required."
+    end
+    
+    it "returns errors if validations fail (tests many errors at once for spec speed)" do
+      params = {
+        :transaction => {
+          :type => "pants",
+          :amount => nil,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          },
+          :customer_id => "invalid",
+          :order_id => "too long" * 250,
+          :payment_method_token => "too long and doesn't belong to customer" * 250
+        }
+      }
+      result = Braintree::Transaction.create(params[:transaction])
+      result.success?.should == false
+      result.errors.for(:transaction).on(:base).map{|error| error.code}.should include(Braintree::ErrorCodes::Transaction::PaymentMethodConflict)
+      result.errors.for(:transaction).on(:base).map{|error| error.code}.should include(Braintree::ErrorCodes::Transaction::PaymentMethodDoesNotBelongToCustomer)
+      result.errors.for(:transaction).on(:amount)[0].code.should == Braintree::ErrorCodes::Transaction::AmountIsRequired
+      result.errors.for(:transaction).on(:customer_id)[0].code.should == Braintree::ErrorCodes::Transaction::CustomerIdIsInvalid
+      result.errors.for(:transaction).on(:order_id)[0].code.should == Braintree::ErrorCodes::Transaction::OrderIdIsTooLong
+      result.errors.for(:transaction).on(:payment_method_token)[0].code.should == Braintree::ErrorCodes::Transaction::PaymentMethodTokenIsInvalid
+      result.errors.for(:transaction).on(:type)[0].code.should == Braintree::ErrorCodes::Transaction::TypeIsInvalid
+
+    end
+    
+    it "returns an error if amount is negative" do
+      params = {
+        :transaction => {
+          :type => "credit",
+          :amount => "-1"
+        }
+      }
+      result = Braintree::Transaction.create(params[:transaction])
+      result.success?.should == false
+      result.errors.for(:transaction).on(:amount)[0].code.should == Braintree::ErrorCodes::Transaction::AmountCannotBeNegative
+    end
+
+    it "returns an error if amount is invalid format" do
+      params = {
+        :transaction => {
+          :type => "sale",
+          :amount => "shorts"
+        }
+      }
+      result = Braintree::Transaction.create(params[:transaction])
+      result.success?.should == false
+      result.errors.for(:transaction).on(:amount)[0].code.should == Braintree::ErrorCodes::Transaction::AmountIsInvalid
+    end
+    
+    it "returns an error if type is not given" do
+      params = {
+        :transaction => {
+          :type => nil
+        }
+      }
+      result = Braintree::Transaction.create(params[:transaction])
+      result.success?.should == false
+      result.errors.for(:transaction).on(:type)[0].code.should == Braintree::ErrorCodes::Transaction::TypeIsRequired
+    end
+    
+    it "returns an error if no credit card is given" do
+      params = {
+        :transaction => {
+        }
+      }
+      result = Braintree::Transaction.create(params[:transaction])
+      result.success?.should == false
+      result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::CreditCardIsRequired
+    end
+    
+    it "returns an error if the given payment method token doesn't belong to the customer" do
+      customer = Braintree::Customer.create!(
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2010"
+        }
+      )
+      result = Braintree::Transaction.create(
+        :type => "sale",
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :customer_id => customer.id,
+        :payment_method_token => customer.credit_cards[0].token + "x"
+      )
+      result.success?.should == false
+      result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::PaymentMethodDoesNotBelongToCustomer
     end
   end
 
@@ -196,6 +315,49 @@ describe Braintree::Transaction do
       transaction.vault_credit_card.token.should == transaction.credit_card_details.token
     end
 
+    it "associates a billing address with a credit card in the vault" do
+      result = Braintree::Transaction.sale(
+        :amount => "100",
+        :customer => {
+          :first_name => "Adam",
+          :last_name => "Williams"
+        },
+        :credit_card => {
+          :number => "5105105105105100",
+          :expiration_date => "05/2012"
+        },
+        :billing => {
+          :first_name => "Carl",
+          :last_name => "Jones",
+          :company => "Braintree",
+          :street_address => "123 E Main St",
+          :extended_address => "Suite 403",
+          :locality => "Chicago",
+          :region => "IL",
+          :postal_code => "60622",
+          :country_name => "United States of America"
+        },
+        :options => {
+          :store_in_vault => true,
+          :add_billing_address_to_payment_method => true,
+        }
+      )
+      result.success?.should == true
+      transaction = result.transaction
+      transaction.customer_details.id.should =~ /\A\d{6,7}\z/
+      transaction.vault_customer.id.should == transaction.customer_details.id
+      credit_card = Braintree::CreditCard.find(transaction.vault_credit_card.token)
+      credit_card.billing_address.first_name.should == "Carl"
+      credit_card.billing_address.last_name.should == "Jones"
+      credit_card.billing_address.company.should == "Braintree"
+      credit_card.billing_address.street_address.should == "123 E Main St"
+      credit_card.billing_address.extended_address.should == "Suite 403"
+      credit_card.billing_address.locality.should == "Chicago"
+      credit_card.billing_address.region.should == "IL"
+      credit_card.billing_address.postal_code.should == "60622"
+      credit_card.billing_address.country_name.should == "United States of America"
+    end
+
     it "submits for settlement if given transaction[options][submit_for_settlement]" do
       result = Braintree::Transaction.sale(
         :amount => "100",
@@ -251,7 +413,7 @@ describe Braintree::Transaction do
       result = Braintree::Transaction.sale(params[:transaction])
       result.success?.should == false
       result.params.should == {:transaction => {:type => 'sale', :amount => nil, :credit_card => {:expiration_date => "05/2009"}}}
-      result.errors.for(:transaction).on(:amount)[0].message.should == "Amount is required."
+      result.errors.for(:transaction).on(:amount)[0].code.should == Braintree::ErrorCodes::Transaction::AmountIsRequired
     end
   end
 
@@ -314,7 +476,7 @@ describe Braintree::Transaction do
       result.transaction.updated_at.between?(Time.now - 5, Time.now).should == true
     end
 
-    it "returns an error result if unsuccessful" do
+    it "returns an error result if settlement is too large" do
       transaction = Braintree::Transaction.sale!(
         :amount => Braintree::Test::TransactionAmounts::Authorize,
         :credit_card => {
@@ -325,9 +487,22 @@ describe Braintree::Transaction do
       transaction.amount.should == "1000.00"
       result = Braintree::Transaction.submit_for_settlement(transaction.id, "1000.01")
       result.success?.should == false
-      result.errors.for(:transaction).on(:amount)[0].message.should == "Settlement amount cannot be more than the authorized amount."
+      result.errors.for(:transaction).on(:amount)[0].code.should == Braintree::ErrorCodes::Transaction::SettlementAmountIsTooLarge
       result.params[:transaction][:amount].should == "1000.01"
     end
+
+    it "returns an error result if status is not authorized" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Decline,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "06/2009"
+        }
+      )
+      result = Braintree::Transaction.submit_for_settlement(transaction.id)
+      result.success?.should == false
+      result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::CannotSubmitForSettlement
+    end
   end
 
   describe "self.submit_for_settlement!" do
@@ -390,7 +565,7 @@ describe Braintree::Transaction do
       result = Braintree::Transaction.credit(params[:transaction])
       result.success?.should == false
       result.params.should == {:transaction => {:type => 'credit', :amount => nil, :credit_card => {:expiration_date => "05/2009"}}}
-      result.errors.for(:transaction).on(:amount)[0].message.should == "Amount is required."
+      result.errors.for(:transaction).on(:amount)[0].code.should == Braintree::ErrorCodes::Transaction::AmountIsRequired
     end
   end
   
@@ -450,7 +625,99 @@ describe Braintree::Transaction do
       transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
       transaction.credit_card_details.expiration_date.should == "05/2009"
     end
-
+    
+    it "can put any param in tr_data" do
+      params = {
+        
+      }
+      tr_data_params = {
+        :transaction => {
+          :amount => "100.00",
+          :order_id => "123",
+          :type => "sale",
+          :credit_card => {
+            :number => "5105105105105100",
+            :expiration_date => "05/2011",
+            :cvv => "123"
+          },
+          :customer => {
+            :first_name => "Dan",
+            :last_name => "Smith",
+            :company => "Braintree Payment Solutions",
+            :email => "dan@example.com",
+            :phone => "419-555-1234",
+            :fax => "419-555-1235",
+            :website => "http://braintreepaymentsolutions.com"
+          },
+          :billing => {
+            :first_name => "Carl",
+            :last_name => "Jones",
+            :company => "Braintree",
+            :street_address => "123 E Main St",
+            :extended_address => "Suite 403",
+            :locality => "Chicago",
+            :region => "IL",
+            :postal_code => "60622",
+            :country_name => "United States of America"
+          },
+          :shipping => {
+            :first_name => "Andrew",
+            :last_name => "Mason",
+            :company => "Braintree",
+            :street_address => "456 W Main St",
+            :extended_address => "Apt 2F",
+            :locality => "Bartlett",
+            :region => "IL",
+            :postal_code => "60103",
+            :country_name => "United States of America"
+          }
+        }
+      }
+      query_string_response = create_transaction_via_tr(params, tr_data_params)
+      result = Braintree::Transaction.create_from_transparent_redirect(query_string_response)
+      transaction = result.transaction
+      transaction.id.should =~ /\A\w{6}\z/
+      transaction.type.should == "sale"
+      transaction.status.should == "authorized"
+      transaction.amount.should == "100.00"
+      transaction.order_id.should == "123"
+      transaction.processor_response_code.should == "1000"
+      transaction.created_at.between?(Time.now - 5, Time.now).should == true
+      transaction.updated_at.between?(Time.now - 5, Time.now).should == true
+      transaction.credit_card_details.bin.should == "510510"
+      transaction.credit_card_details.last_4.should == "5100"
+      transaction.credit_card_details.masked_number.should == "510510******5100"
+      transaction.credit_card_details.card_type.should == "MasterCard"
+      transaction.avs_error_response_code.should == nil
+      transaction.avs_postal_code_response_code.should == "M"
+      transaction.avs_street_address_response_code.should == "M"
+      transaction.customer_details.first_name.should == "Dan"
+      transaction.customer_details.last_name.should == "Smith"
+      transaction.customer_details.company.should == "Braintree Payment Solutions"
+      transaction.customer_details.email.should == "dan@example.com"
+      transaction.customer_details.phone.should == "419-555-1234"
+      transaction.customer_details.fax.should == "419-555-1235"
+      transaction.customer_details.website.should == "http://braintreepaymentsolutions.com"
+      transaction.billing_details.first_name.should == "Carl"
+      transaction.billing_details.last_name.should == "Jones"
+      transaction.billing_details.company.should == "Braintree"
+      transaction.billing_details.street_address.should == "123 E Main St"
+      transaction.billing_details.extended_address.should == "Suite 403"
+      transaction.billing_details.locality.should == "Chicago"
+      transaction.billing_details.region.should == "IL"
+      transaction.billing_details.postal_code.should == "60622"
+      transaction.billing_details.country_name.should == "United States of America"
+      transaction.shipping_details.first_name.should == "Andrew"
+      transaction.shipping_details.last_name.should == "Mason"
+      transaction.shipping_details.company.should == "Braintree"
+      transaction.shipping_details.street_address.should == "456 W Main St"
+      transaction.shipping_details.extended_address.should == "Apt 2F"
+      transaction.shipping_details.locality.should == "Bartlett"
+      transaction.shipping_details.region.should == "IL"
+      transaction.shipping_details.postal_code.should == "60103"
+      transaction.shipping_details.country_name.should == "United States of America"
+    end
+    
     it "returns an error result if validations fail" do
       params = {
         :transaction => {
@@ -470,7 +737,7 @@ describe Braintree::Transaction do
       result = Braintree::Transaction.create_from_transparent_redirect(query_string_response)
       result.success?.should == false
       result.params[:transaction].should == {:amount => "", :type => "sale", :credit_card => {:expiration_date => "05/2009"}}
-      result.errors.for(:transaction).on(:amount)[0].message.should == "Amount is required."
+      result.errors.for(:transaction).on(:amount)[0].code.should == Braintree::ErrorCodes::Transaction::AmountIsRequired
     end
   end
   
@@ -522,7 +789,7 @@ describe Braintree::Transaction do
       )
       result = Braintree::Transaction.void(transaction.id)
       result.success?.should == false
-      result.errors.for(:transaction).on(:base)[0].message.should == "Transaction can only be voided if status is authorized or submitted_for_settlement."
+      result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::CannotBeVoided
     end
   end
 
@@ -562,7 +829,16 @@ describe Braintree::Transaction do
       result.new_transaction.type.should == "credit"
     end
 
-    it "returns an error result if unsuccessful" do
+    it "returns an error if already refunded" do
+      transaction = find_transaction_to_refund
+      result = transaction.refund
+      result.success?.should == true
+      result = transaction.refund
+      result.success?.should == false
+      result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::HasAlreadyBeenRefunded
+    end
+
+    it "returns an error result if unsettled" do
       transaction = Braintree::Transaction.create!(
         :type => "sale",
         :amount => Braintree::Test::TransactionAmounts::Authorize,
@@ -573,7 +849,7 @@ describe Braintree::Transaction do
       )
       result = transaction.refund
       result.success?.should == false
-      result.errors.for(:transaction).on(:base)[0].message.should == "Cannot refund a transaction unless it is settled."
+      result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::CannotRefundUnlessSettled
     end
   end
 
@@ -631,7 +907,7 @@ describe Braintree::Transaction do
       transaction.amount.should == "1000.00"
       result = transaction.submit_for_settlement("1000.01")
       result.success?.should == false
-      result.errors.for(:transaction).on(:amount)[0].message.should == "Settlement amount cannot be more than the authorized amount."
+      result.errors.for(:transaction).on(:amount)[0].code.should == Braintree::ErrorCodes::Transaction::SettlementAmountIsTooLarge
       result.params[:transaction][:amount].should == "1000.01"
     end
   end
@@ -762,6 +1038,22 @@ describe Braintree::Transaction do
       end
     end
   end
+
+  describe "status_history" do
+    it "returns an array of StatusDetail" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        }
+      )
+      transaction.submit_for_settlement!
+      transaction.status_history.size.should == 2
+      transaction.status_history[0].status.should == "authorized"
+      transaction.status_history[1].status.should == "submitted_for_settlement"
+    end
+  end
   
   describe "vault_credit_card" do
     it "returns the Braintree::CreditCard if the transaction credit card is stored in the vault" do
@@ -843,7 +1135,7 @@ describe Braintree::Transaction do
       transaction.status.should == "processor_declined"
       result = transaction.void
       result.success?.should == false
-      result.errors.for(:transaction).on(:base)[0].message.should == "Transaction can only be voided if status is authorized or submitted_for_settlement."
+      result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::CannotBeVoided
     end
   end
 

data/spec/integration/spec_helper.rb

@@ -1,38 +1,44 @@
-require File.dirname(__FILE__) + "/../spec_helper"
+unless defined?(INTEGRATION_SPEC_HELPER_LOADED)
+  INTEGRATION_SPEC_HELPER_LOADED = true
 
-require 'timeout'
-require 'socket'
+  require File.dirname(__FILE__) + "/../spec_helper"
+  require File.dirname(__FILE__) + "/../hacks/tcp_socket"
 
+  Spec::Runner.configure do |config|
+    CLIENT_LIB_ROOT = File.expand_path(File.dirname(__FILE__) + "/../..")
+    GATEWAY_ROOT = File.expand_path("#{CLIENT_LIB_ROOT}/../gateway")
+    GATEWAY_SERVER_PORT = 3000
+    GATEWAY_PID_FILE = "/tmp/gateway_server_#{Braintree::Configuration.port}.pid"
+    SPHINX_PID_FILE = "#{GATEWAY_ROOT}/log/searchd.integration.pid"
+    
+    gateway_already_started = File.exist?(GATEWAY_PID_FILE)
+    sphinx_already_started = File.exist?(SPHINX_PID_FILE)
+    config.before(:suite) do
+       Dir.chdir(CLIENT_LIB_ROOT) do
+        system "rake start_gateway" or raise "rake start_gateway failed" unless gateway_already_started
+        system "rake start_sphinx" or raise "rake start_sphinx failed" unless sphinx_already_started
+      end
+    end
 
-def start_ssl_server
-  web_server_pid_file = File.expand_path(File.join(File.dirname(__FILE__), "..", "httpsd.pid"))
-
-  TCPSocket.class_eval do
-    def self.wait_for_service(options)
-      Timeout::timeout(options[:timeout] || 20) do
-        loop do
-          begin
-            socket = TCPSocket.new(options[:host], options[:port])
-            socket.close
-            return
-          rescue Errno::ECONNREFUSED
-            sleep 0.5
-          end
-        end
+    config.after(:suite) do
+      Dir.chdir(CLIENT_LIB_ROOT) do
+        system "rake stop_gateway" or raise "rake stop_gateway failed" unless gateway_already_started
+        system "rake stop_sphinx" or raise "rake stop_sphinx failed" unless sphinx_already_started
       end
     end
   end
 
-  FileUtils.rm(web_server_pid_file) if File.exist?(web_server_pid_file)
-  command = File.expand_path(File.join(File.dirname(__FILE__), "..", "script", "httpsd.rb"))
-  #puts command
-  `#{command} #{web_server_pid_file}`
-  #puts "== waiting for web server - port: #{8433}"
-  TCPSocket.wait_for_service :host => "127.0.0.1", :port => 8443
+  def start_ssl_server
+    web_server_pid_file = File.expand_path(File.join(File.dirname(__FILE__), "..", "httpsd.pid"))
 
-  yield
+    FileUtils.rm(web_server_pid_file) if File.exist?(web_server_pid_file)
+    command = File.expand_path(File.join(File.dirname(__FILE__), "..", "script", "httpsd.rb"))
+    `#{command} #{web_server_pid_file}`
+    TCPSocket.wait_for_service :host => "127.0.0.1", :port => 8443
 
-  10.times { unless File.exists?(web_server_pid_file); sleep 1; end }
-  #puts "\n== killing web server - pid: #{File.read(web_server_pid_file).to_i}"
-  Process.kill "INT", File.read(web_server_pid_file).to_i
+    yield
+
+    10.times { unless File.exists?(web_server_pid_file); sleep 1; end }
+    Process.kill "INT", File.read(web_server_pid_file).to_i
+  end
 end

data/spec/spec_helper.rb

@@ -16,9 +16,6 @@ unless defined?(SPEC_HELPER_LOADED)
   Braintree::Configuration.logger = Logger.new("/dev/null")
   Braintree::Configuration.logger.level = Logger::INFO
 
-  Spec::Runner.configure do |config|
-  end
-
   module SpecHelper
     def self.stub_time_dot_now(desired_time)
       Time.class_eval do

data/spec/unit/braintree/transaction_spec.rb

@@ -76,6 +76,24 @@ describe Braintree::Transaction do
       transaction.credit_card_details.issuer_location.should == "US"
     end
 
+    it "sets up history attributes in status_history" do
+      time = Time.utc(2010,1,14)
+      transaction = Braintree::Transaction._new(
+        :status_history => [
+          { :timestamp => time, :amount => "12.00", :transaction_source => "API", 
+            :user => "larry", :status => "authorized" },
+          { :timestamp => Time.utc(2010,1,15), :amount => "12.00", :transaction_source => "API",
+            :user => "curly", :status => "scheduled_for_settlement"}
+        ])
+      transaction.status_history.size.should == 2
+      transaction.status_history[0].user.should == "larry"
+      transaction.status_history[0].amount.should == "12.00"
+      transaction.status_history[0].status.should == "authorized"
+      transaction.status_history[0].transaction_source.should == "API"
+      transaction.status_history[0].timestamp.should == time
+      transaction.status_history[1].user.should == "curly"
+    end
+
     it "handles receiving custom as an empty string" do
       transaction = Braintree::Transaction._new(
         :custom => "\n    "

data/spec/unit/braintree/util_spec.rb

@@ -28,7 +28,33 @@ describe Braintree::Util do
         )
       end.to raise_error(ArgumentError, "invalid keys: nested[nested_invalid], top_level_invalid")
     end
-    
+
+    it "does not raise an exception for wildcards" do
+      expect do
+        Braintree::Util.verify_keys(
+          [:allowed, {:custom_fields => :_any_key_}],
+          :allowed => "ok",
+          :custom_fields => {
+            :custom_allowed => "ok",
+            :custom_allowed2 => "also ok",
+          }
+        )
+      end.to_not raise_error
+    end
+
+    it "raise an exception for wildcards at different nesting" do
+      expect do
+        Braintree::Util.verify_keys(
+          [:allowed, {:custom_fields => :_any_key_}],
+          :allowed => {
+            :custom_fields => {
+              :bad_nesting => "very bad"
+            }
+          }
+        )
+      end.to raise_error(ArgumentError, "invalid keys: allowed[custom_fields][bad_nesting]")
+    end    
+
     it "raises an exception if a deeply nested hash contains an invalid key" do
       expect do
         Braintree::Util.verify_keys(
@@ -65,6 +91,12 @@ describe Braintree::Util do
         [:top_level, {:nested => [:nested_allowed, :nested_allowed2]}]
       ).should == ["nested[nested_allowed2]", "nested[nested_allowed]", "top_level"]
     end
+
+    it "allows wildcards with the :_any_key_ symbol" do
+      Braintree::Util._flatten_valid_keys(
+        [:top_level, {:nested => :_any_key_}]
+      ).should == ["nested[_any_key_]", "top_level"]
+    end
   end
 
   describe "self.extract_attribute_as_array" do
@@ -92,6 +124,11 @@ describe Braintree::Util do
       hash = {:foo => {:key_one => "value_one", :key_two => "value_two"}}
       Braintree::Util.hash_to_query_string(hash).should == "foo%5Bkey_one%5D=value_one&foo%5Bkey_two%5D=value_two"
     end
+    
+    it "works for nesting 2 levels deep" do
+      hash = {:foo => {:nested => {:key_one => "value_one", :key_two => "value_two"}}}
+      Braintree::Util.hash_to_query_string(hash).should == "foo%5Bnested%5D%5Bkey_one%5D=value_one&foo%5Bnested%5D%5Bkey_two%5D=value_two"
+    end
   end
   
   describe "self.parse_query_string" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: braintree
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors: 
 - Braintree Payment Solutions
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-18 00:00:00 -06:00
+date: 2010-01-20 00:00:00 -06:00
 default_executable: 
 dependencies: []
 
@@ -43,6 +43,7 @@ files:
 - lib/braintree/transaction/address_details.rb
 - lib/braintree/transaction/credit_card_details.rb
 - lib/braintree/transaction/customer_details.rb
+- lib/braintree/transaction/status_details.rb
 - lib/braintree/transaction.rb
 - lib/braintree/transparent_redirect.rb
 - lib/braintree/util.rb
@@ -54,9 +55,11 @@ files:
 - lib/braintree/xml/parser.rb
 - lib/braintree/xml.rb
 - lib/braintree.rb
+- spec/hacks/tcp_socket.rb
 - spec/integration/braintree/address_spec.rb
 - spec/integration/braintree/credit_card_spec.rb
 - spec/integration/braintree/customer_spec.rb
+- spec/integration/braintree/error_codes_spec.rb
 - spec/integration/braintree/http_spec.rb
 - spec/integration/braintree/test/transaction_amounts_spec.rb
 - spec/integration/braintree/transaction_spec.rb