braintree 2.0.0 → 2.1.0

data/spec/integration/braintree/transaction_spec.rb

@@ -199,6 +199,51 @@ describe Braintree::Transaction do
       result.success?.should == false
       result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::PaymentMethodDoesNotBelongToCustomer
     end
+
+    context "new credit card for existing customer" do
+      it "allows a new credit card to be used for an existing 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,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/12"
+          }
+        )
+        result.success?.should == true
+        result.transaction.credit_card_details.masked_number.should == "401288******1881"
+        result.transaction.vault_credit_card.should be_nil
+      end
+
+      it "allows a new credit card to be used and stored in the vault" 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,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/12",
+          },
+          :options => { :store_in_vault => true }
+        )
+        result.success?.should == true
+        result.transaction.credit_card_details.masked_number.should == "401288******1881"
+        result.transaction.vault_credit_card.masked_number.should == "401288******1881"
+      end
+    end
   end
 
   describe "self.create!" do
@@ -301,8 +346,8 @@ describe Braintree::Transaction do
       transaction.amount.should == BigDecimal.new("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.created_at.between?(Time.now - 60, Time.now).should == true
+      transaction.updated_at.between?(Time.now - 60, Time.now).should == true
       transaction.credit_card_details.bin.should == "510510"
       transaction.credit_card_details.cardholder_name.should == "The Cardholder"
       transaction.credit_card_details.last_4.should == "5100"
@@ -339,6 +384,31 @@ describe Braintree::Transaction do
       transaction.shipping_details.country_name.should == "United States of America"
     end
 
+    it "allows merchant account to be specified" do
+      result = Braintree::Transaction.sale(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        }
+      )
+      result.success?.should == true
+      result.transaction.merchant_account_id.should == SpecHelper::NonDefaultMerchantAccountId
+    end
+
+    it "uses default merchant account when it is not specified" do
+      result = Braintree::Transaction.sale(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        }
+      )
+      result.success?.should == true
+      result.transaction.merchant_account_id.should == SpecHelper::DefaultMerchantAccountId
+    end
+
     it "can store customer and credit card in the vault" do
       result = Braintree::Transaction.sale(
         :amount => "100",
@@ -660,6 +730,31 @@ describe Braintree::Transaction do
       result.params.should == {:transaction => {:type => 'credit', :amount => nil, :credit_card => {:expiration_date => "05/2009"}}}
       result.errors.for(:transaction).on(:amount)[0].code.should == Braintree::ErrorCodes::Transaction::AmountIsRequired
     end
+
+    it "allows merchant account to be specified" do
+      result = Braintree::Transaction.credit(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        }
+      )
+      result.success?.should == true
+      result.transaction.merchant_account_id.should == SpecHelper::NonDefaultMerchantAccountId
+    end
+
+    it "uses default merchant account when it is not specified" do
+      result = Braintree::Transaction.credit(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        }
+      )
+      result.success?.should == true
+      result.transaction.merchant_account_id.should == SpecHelper::DefaultMerchantAccountId
+    end
   end
 
   describe "self.credit!" do
@@ -721,6 +816,30 @@ describe Braintree::Transaction do
       transaction.credit_card_details.expiration_date.should == "05/2009"
     end
 
+    it "raises an error with a message if given invalid params" do
+      params = {
+        :transaction => {
+          :bad => "value",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          }
+        }
+      }
+      tr_data_params = {
+        :transaction => {
+          :type => "sale"
+        }
+      }
+      tr_data = Braintree::TransparentRedirect.transaction_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
+      query_string_response = SpecHelper.simulate_form_post_for_tr(Braintree::Transaction.create_transaction_url, tr_data, params)
+
+      expect do
+        Braintree::Transaction.create_from_transparent_redirect(query_string_response)
+      end.to raise_error(Braintree::AuthorizationError, "Invalid params: transaction[bad]")
+    end
+
     it "can put any param in tr_data" do
       params = {
 
@@ -924,6 +1043,23 @@ describe Braintree::Transaction do
   end
 
   describe "refund" do
+    context "partial refunds" do
+      it "allows partial refunds" do
+        transaction = create_transaction_to_refund
+        result = transaction.refund(transaction.amount / 2)
+        result.success?.should == true
+        result.new_transaction.type.should == "credit"
+      end
+
+      it "does not all multiple refunds" do
+        transaction = create_transaction_to_refund
+        transaction.refund(transaction.amount / 2)
+        result = transaction.refund(BigDecimal.new("1"))
+        result.success?.should == false
+        result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::HasAlreadyBeenRefunded
+      end
+    end
+
     it "returns a successful result if successful" do
       transaction = create_transaction_to_refund
       transaction.status.should == Braintree::Transaction::Status::Settled
@@ -1044,101 +1180,6 @@ describe Braintree::Transaction do
     end
   end
 
-  describe "search" do
-    describe "advanced" do
-      it "pretty much works in one big fell swoop/hash" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "05/2009"
-          },
-          :order_id => "123",
-          :customer => {
-            :company => "Apple",
-            :fax => "312-555-1234",
-            :first_name => "Steve",
-            :last_name => "Jobs",
-            :phone => "614-555-1234",
-            :website => "http://www.apple.com",
-          },
-          :billing => {
-            :country_name => "United States of America",
-            :extended_address => "Apt 1F",
-            :locality => "Chicago",
-            :postal_code => "60622",
-            :region => "Illinois",
-            :street_address => "1234 W North Ave",
-          },
-          :shipping => {
-            :country_name => "United States of America",
-            :extended_address => "Apt 123",
-            :locality => "Bartlett",
-            :postal_code => "60004",
-            :region => "Illinois",
-            :street_address => "123 Main St",
-          }
-        )
-        result.success?.should == true
-        expected_transaction = result.transaction
-        search_criteria = {
-          :billing_country_name => {:is => "United States of America"},
-          :billing_extended_address => {:is => "Apt 1F"},
-          :billing_locality => {:is => "Chicago"},
-          :billing_postal_code => {:is => "60622"},
-          :billing_region => {:is => "Illinois"},
-          :billing_street_address => {:is => "1234 W North Ave"},
-          :credit_card_number => {:is => Braintree::Test::CreditCardNumbers::Visa},
-          :customer_company => {:is => "Apple"},
-          :customer_fax => {:is => "312-555-1234"},
-          :customer_first_name => {:is => "Steve"},
-          :customer_last_name => {:is => "Jobs"},
-          :customer_phone => {:is => "614-555-1234"},
-          :customer_website => {:is => "http://www.apple.com"},
-          :expiration_date => {:is => "05/2009"},
-          :order_id => {:is => "123"},
-          :shipping_country_name => {:is => "United States of America"},
-          :shipping_extended_address => {:is => "Apt 123"},
-          :shipping_locality => {:is => "Bartlett"},
-          :shipping_postal_code => {:is => "60004"},
-          :shipping_region => {:is => "Illinois"},
-          :shipping_street_address => {:is => "123 Main St"},
-        }
-        search_results = Braintree::Transaction.search(search_criteria)
-        search_results.should include(expected_transaction)
-      end
-
-      it "properly parses the xml if only one transaction is found" do
-        transaction = Braintree::Transaction.create!(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "05/2009"
-          }
-        )
-        search_results = Braintree::Transaction.search(:transaction_id => {:is => transaction.id})
-        search_results.first.should == transaction
-      end
-    end
-
-    describe "basic" do
-      it "returns transactions matching the given search terms" do
-        transactions = Braintree::Transaction.search "1111"
-        transactions._approximate_size.should > 0
-      end
-
-      it "can iterate over the entire collection" do
-        transactions = Braintree::Transaction.search "411111"
-        transactions._approximate_size.should > 100
-
-        transaction_ids = transactions.map {|t| t.id }.uniq.compact
-        transaction_ids.size.should == transactions._approximate_size
-      end
-    end
-  end
-
   describe "status_history" do
     it "returns an array of StatusDetail" do
       transaction = Braintree::Transaction.sale!(

data/spec/spec_helper.rb

@@ -17,6 +17,10 @@ unless defined?(SPEC_HELPER_LOADED)
   Braintree::Configuration.logger.level = Logger::INFO
 
   module SpecHelper
+
+    DefaultMerchantAccountId = "sandbox_credit_card"
+    NonDefaultMerchantAccountId = "sandbox_credit_card_non_default"
+
     def self.stub_time_dot_now(desired_time)
       Time.class_eval do
         class << self

data/spec/unit/braintree/credit_card_spec.rb

@@ -10,14 +10,56 @@ describe Braintree::CreditCard do
   end
 
   describe "self.create_signature" do
-    it "should include customer_id" do
-      Braintree::CreditCard._create_signature.should include(:customer_id)
+    it "should be what we expect" do
+      Braintree::CreditCard._create_signature.should == [
+        :cardholder_name,
+        :cvv,
+        :expiration_date,
+        :expiration_month,
+        :expiration_year,
+        :number,
+        :token,
+        {:options => [:make_default, :verify_card]},
+        {:billing_address => [
+          :company,
+          :country_name,
+          :extended_address,
+          :first_name,
+          :last_name,
+          :locality,
+          :postal_code,
+          :region,
+          :street_address
+        ]},
+        :customer_id
+      ]
     end
   end
 
   describe "self.update_signature" do
-    it "should not include customer_id" do
-      Braintree::CreditCard._update_signature.should_not include(:customer_id)
+    it "should be what we expect" do
+      Braintree::CreditCard._update_signature.should == [
+        :cardholder_name,
+        :cvv,
+        :expiration_date,
+        :expiration_month,
+        :expiration_year,
+        :number,
+        :token,
+        {:options => [:make_default, :verify_card]},
+        {:billing_address => [
+          :company,
+          :country_name,
+          :extended_address,
+          :first_name,
+          :last_name,
+          :locality,
+          :postal_code,
+          :region,
+          :street_address,
+          {:options => [:update_existing]}
+        ]}
+      ]
     end
   end
 

data/spec/unit/braintree/subscription_spec.rb

@@ -3,13 +3,13 @@ require File.dirname(__FILE__) + "/../spec_helper"
 describe Braintree::Subscription do
   context "price" do
     it "accepts price as either a String or a BigDecimal" do
-      Braintree::Subscription.new(:price => "12.34", :transactions => []).price.should == BigDecimal.new("12.34")
-      Braintree::Subscription.new(:price => BigDecimal.new("12.34"), :transactions => []).price.should == BigDecimal.new("12.34")
+      Braintree::Subscription._new(:price => "12.34", :transactions => []).price.should == BigDecimal.new("12.34")
+      Braintree::Subscription._new(:price => BigDecimal.new("12.34"), :transactions => []).price.should == BigDecimal.new("12.34")
     end
 
     it "blows up if price is not a string or BigDecimal" do
       expect {
-        Braintree::Subscription.new(:price => 12.34, :transactions => [])
+        Braintree::Subscription._new(:price => 12.34, :transactions => [])
       }.to raise_error(/Argument must be a String or BigDecimal/)
     end
   end
@@ -23,4 +23,23 @@ describe Braintree::Subscription do
       end.should raise_error(ArgumentError)
     end
   end
+
+  describe "==" do
+    it "returns true for subscriptions with the same id" do
+      subscription1 = Braintree::Subscription._new(:id => "123", :transactions => [])
+      subscription2 = Braintree::Subscription._new(:id => "123", :transactions => [])
+      subscription1.should == subscription2
+    end
+
+    it "returns false for subscriptions with different ids" do
+      subscription1 = Braintree::Subscription._new(:id => "123", :transactions => [])
+      subscription2 = Braintree::Subscription._new(:id => "not_123", :transactions => [])
+      subscription1.should_not == subscription2
+    end
+
+    it "returns false if not comparing to a subscription" do
+      subscription = Braintree::Subscription._new(:id => "123", :transactions => [])
+      subscription.should_not == "not a subscription"
+    end
+  end
 end

data/spec/unit/braintree/transaction_search_spec.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Braintree::TransactionSearch do
+	it "overrides previous 'is' with new 'is' for the same field" do
+		search = Braintree::TransactionSearch.new
+		search.billing_company.is "one"
+		search.billing_company.is "two"
+		search.to_hash.should == {:billing_company => {:is => "two"}}
+	end
+
+	it "overrides previous 'in' with new 'in' for the same field" do
+		search = Braintree::TransactionSearch.new
+		search.status.in Braintree::Transaction::Status::Authorized
+		search.status.in Braintree::Transaction::Status::SubmittedForSettlement
+		search.to_hash.should == {:status => [Braintree::Transaction::Status::SubmittedForSettlement]}
+	end
+
+  it "raises if the operator 'is' is left off" do
+    search = Braintree::TransactionSearch.new
+    expect do
+      search.billing_company "one"
+    end.to raise_error(RuntimeError, "An operator is required")
+  end
+end

data/spec/unit/braintree/transaction_spec.rb

@@ -127,7 +127,7 @@ describe Braintree::Transaction do
   end
 
   describe "==" do
-    it "returns true when it should" do
+    it "returns true for transactions with the same id" do
       first = Braintree::Transaction._new(:id => 123)
       second = Braintree::Transaction._new(:id => 123)
 
@@ -135,13 +135,24 @@ describe Braintree::Transaction do
       second.should == first
     end
 
-    it "returns false when it should" do
+    it "returns false for transactions with different ids" do
       first = Braintree::Transaction._new(:id => 123)
       second = Braintree::Transaction._new(:id => 124)
 
       first.should_not == second
       second.should_not == first
     end
+
+    it "returns false when comparing to nil" do
+      Braintree::Transaction._new({}).should_not == nil
+    end
+
+    it "returns false when comparing to non-transactions" do
+      same_id_different_object = Object.new
+      def same_id_different_object.id; 123; end
+      transaction = Braintree::Transaction._new(:id => 123)
+      transaction.should_not == same_id_different_object
+    end
   end
 
   describe "new" do