braintree 2.4.0 → 2.5.1

data/spec/integration/braintree/transaction_search_spec.rb

@@ -18,49 +18,53 @@ describe Braintree::Transaction, "search" do
       transaction = Braintree::Transaction.sale!(
         :amount => Braintree::Test::TransactionAmounts::Authorize,
         :credit_card => {
-        :number => Braintree::Test::CreditCardNumbers::Visa,
-        :expiration_date => "05/2012",
-        :cardholder_name => "Tom Smith",
-        :token => token,
-      },
-      :billing => {
-        :company => "Braintree",
-        :country_name => "United States of America",
-        :extended_address => "Suite 123",
-        :first_name => first_name,
-        :last_name => "Smith",
-        :locality => "Chicago",
-        :postal_code => "12345",
-        :region => "IL",
-        :street_address => "123 Main St"
-      },
-      :customer => {
-        :company => "Braintree",
-        :email => "smith@example.com",
-        :fax => "5551231234",
-        :first_name => "Tom",
-        :id => customer_id,
-        :last_name => "Smith",
-        :phone => "5551231234",
-        :website => "http://example.com",
-      },
-      :options => {
-        :store_in_vault => true
-      },
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2012",
+          :cardholder_name => "Tom Smith",
+          :token => token,
+        },
+        :billing => {
+          :company => "Braintree",
+          :country_name => "United States of America",
+          :extended_address => "Suite 123",
+          :first_name => first_name,
+          :last_name => "Smith",
+          :locality => "Chicago",
+          :postal_code => "12345",
+          :region => "IL",
+          :street_address => "123 Main St"
+        },
+        :customer => {
+          :company => "Braintree",
+          :email => "smith@example.com",
+          :fax => "5551231234",
+          :first_name => "Tom",
+          :id => customer_id,
+          :last_name => "Smith",
+          :phone => "5551231234",
+          :website => "http://example.com",
+        },
+        :options => {
+          :store_in_vault => true,
+          :submit_for_settlement => true
+        },
         :order_id => "myorder",
         :shipping => {
-        :company => "Braintree P.S.",
-        :country_name => "Mexico",
-        :extended_address => "Apt 456",
-        :first_name => "Thomas",
-        :last_name => "Smithy",
-        :locality => "Braintree",
-        :postal_code => "54321",
-        :region => "MA",
-        :street_address => "456 Road"
-      }
+          :company => "Braintree P.S.",
+          :country_name => "Mexico",
+          :extended_address => "Apt 456",
+          :first_name => "Thomas",
+          :last_name => "Smithy",
+          :locality => "Braintree",
+          :postal_code => "54321",
+          :region => "MA",
+          :street_address => "456 Road"
+        }
       )
 
+      SpecHelper.settle_transaction transaction.id
+      transaction = Braintree::Transaction.find(transaction.id)
+
       search_criteria = {
         :billing_company => "Braintree",
         :billing_country_name => "United States of America",
@@ -85,6 +89,7 @@ describe Braintree::Transaction, "search" do
         :order_id => "myorder",
         :payment_method_token => token,
         :processor_authorization_code => transaction.processor_authorization_code,
+        :settlement_batch_id => transaction.settlement_batch_id,
         :shipping_company => "Braintree P.S.",
         :shipping_country_name => "Mexico",
         :shipping_extended_address => "Apt 456",
@@ -416,7 +421,7 @@ describe Braintree::Transaction, "search" do
         },
         :options => { :submit_for_settlement => true }
         )
-        Braintree::Http.put "/transactions/#{transaction.id}/settle"
+        SpecHelper.settle_transaction transaction.id
 
         refund_transaction = transaction.refund.new_transaction
 
@@ -612,9 +617,9 @@ describe Braintree::Transaction, "search" do
           transaction = Braintree::Transaction.sale!(
             :amount => Braintree::Test::TransactionAmounts::Authorize,
             :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "05/12"
-          }
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/12"
+            }
           )
 
           collection = Braintree::Transaction.search do |search|
@@ -629,6 +634,276 @@ describe Braintree::Transaction, "search" do
           collection.first.id.should == transaction.id
         end
       end
+
+      context "status date ranges" do
+        it "finds transactions authorized in a given range" 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.authorized_at.between(
+              Date.today - 2,
+              Date.today - 1
+            )
+          end
+
+          collection.maximum_size.should == 0
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction.id
+            search.authorized_at.between(
+              Date.today - 1,
+              Date.today + 1
+            )
+          end
+
+          collection.maximum_size.should == 1
+          collection.first.id.should == transaction.id
+        end
+
+        it "finds transactions failed in a given range" do
+          transaction = Braintree::Transaction.sale(
+            :amount => Braintree::Test::TransactionAmounts::Fail,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/12"
+            }
+          ).transaction
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction.id
+            search.failed_at.between(
+              Date.today - 2,
+              Date.today - 1
+            )
+          end
+
+          collection.maximum_size.should == 0
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction.id
+            search.failed_at.between(
+              Date.today - 1,
+              Date.today + 1
+            )
+          end
+
+          collection.maximum_size.should == 1
+          collection.first.id.should == transaction.id
+        end
+
+        it "finds transactions gateway_rejected in a given range" 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"
+
+            transaction = Braintree::Transaction.sale(
+              :amount => Braintree::Test::TransactionAmounts::Authorize,
+              :credit_card => {
+                :number => Braintree::Test::CreditCardNumbers::Visa,
+                :expiration_date => "05/12",
+                :cvv => "200"
+              }
+            ).transaction
+
+            collection = Braintree::Transaction.search do |search|
+              search.id.is transaction.id
+              search.gateway_rejected_at.between(
+                Date.today - 2,
+                Date.today - 1
+              )
+            end
+
+            collection.maximum_size.should == 0
+
+            collection = Braintree::Transaction.search do |search|
+              search.id.is transaction.id
+              search.gateway_rejected_at.between(
+                Date.today - 1,
+                Date.today + 1
+              )
+            end
+
+            collection.maximum_size.should == 1
+            collection.first.id.should == transaction.id
+          ensure
+            Braintree::Configuration.merchant_id = old_merchant
+            Braintree::Configuration.public_key = old_public_key
+            Braintree::Configuration.private_key = old_private_key
+          end
+        end
+
+        it "finds transactions processor declined in a given range" do
+          transaction = Braintree::Transaction.sale(
+            :amount => Braintree::Test::TransactionAmounts::Decline,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/12"
+            }
+          ).transaction
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction.id
+            search.processor_declined_at.between(
+              Date.today - 2,
+              Date.today - 1
+            )
+          end
+
+          collection.maximum_size.should == 0
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction.id
+            search.processor_declined_at.between(
+              Date.today - 1,
+              Date.today + 1
+            )
+          end
+
+          collection.maximum_size.should == 1
+          collection.first.id.should == transaction.id
+        end
+
+        it "finds transactions settled in a given range" do
+          transaction = Braintree::Transaction.sale(
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/12"
+            },
+            :options => {
+              :submit_for_settlement => true
+            }
+          ).transaction
+
+          SpecHelper.settle_transaction transaction.id
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction.id
+            search.settled_at.between(
+              Date.today - 2,
+              Date.today - 1
+            )
+          end
+
+          collection.maximum_size.should == 0
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction.id
+            search.settled_at.between(
+              Date.today - 1,
+              Date.today + 1
+            )
+          end
+
+          collection.maximum_size.should == 1
+          collection.first.id.should == transaction.id
+        end
+
+        it "finds transactions submitted for settlement in a given range" do
+          transaction = Braintree::Transaction.sale(
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/12"
+            },
+            :options => {
+              :submit_for_settlement => true
+            }
+          ).transaction
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction.id
+            search.submitted_for_settlement_at.between(
+              Date.today - 2,
+              Date.today - 1
+            )
+          end
+
+          collection.maximum_size.should == 0
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction.id
+            search.submitted_for_settlement_at.between(
+              Date.today - 1,
+              Date.today + 1
+            )
+          end
+
+          collection.maximum_size.should == 1
+          collection.first.id.should == transaction.id
+        end
+
+        it "finds transactions voided in a given range" do
+          transaction = Braintree::Transaction.sale!(
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/12"
+            }
+          )
+          transaction = Braintree::Transaction.void(transaction.id).transaction
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction.id
+            search.voided_at.between(
+              Date.today - 2,
+              Date.today - 1
+            )
+          end
+
+          collection.maximum_size.should == 0
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction.id
+            search.voided_at.between(
+              Date.today - 1,
+              Date.today + 1
+            )
+          end
+
+          collection.maximum_size.should == 1
+          collection.first.id.should == transaction.id
+        end
+      end
+
+      it "allows searching on multiple statuses" do
+          transaction = Braintree::Transaction.sale!(
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/12"
+            },
+            :options => {
+              :submit_for_settlement => true
+            }
+          )
+
+          collection = Braintree::Transaction.search do |search|
+            search.id.is transaction.id
+            search.authorized_at.between(
+              Date.today - 1,
+              Date.today + 1
+            )
+            search.submitted_for_settlement_at.between(
+              Date.today - 1,
+              Date.today + 1
+            )
+          end
+
+          collection.maximum_size.should > 0
+      end
     end
 
     it "returns multiple results" do

data/spec/integration/braintree/transaction_spec.rb

@@ -231,7 +231,7 @@ describe Braintree::Transaction do
             }
           )
           result.success?.should == false
-          result.transaction.gateway_rejection_reason.should == Braintree::Transaction::GatewayRejectionReason::AVS_AND_CVV
+          result.transaction.gateway_rejection_reason.should == Braintree::Transaction::GatewayRejectionReason::AVSAndCVV
         ensure
           Braintree::Configuration.merchant_id = old_merchant
           Braintree::Configuration.public_key = old_public_key
@@ -446,6 +446,72 @@ describe Braintree::Transaction do
         result.transaction.vault_credit_card.masked_number.should == "401288******1881"
       end
     end
+
+    it "snapshots add_ons and discounts from subscription" do
+      customer = Braintree::Customer.create!(
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2010"
+        }
+      )
+
+      result = Braintree::Subscription.create(
+        :payment_method_token => customer.credit_cards.first.token,
+        :plan_id => SpecHelper::TriallessPlan[:id],
+        :add_ons => {
+          :add => [
+            {
+              :amount => BigDecimal.new("11.00"),
+              :inherited_from_id => SpecHelper::AddOnIncrease10,
+              :quantity => 2,
+              :number_of_billing_cycles => 5
+            },
+            {
+              :amount => BigDecimal.new("21.00"),
+              :inherited_from_id => SpecHelper::AddOnIncrease20,
+              :quantity => 3,
+              :number_of_billing_cycles => 6
+            }
+          ]
+        },
+        :discounts => {
+          :add => [
+            {
+              :amount => BigDecimal.new("7.50"),
+              :inherited_from_id => SpecHelper::Discount7,
+              :quantity => 2,
+              :never_expires => true
+            }
+          ]
+        }
+      )
+
+      result.success?.should be_true
+      transaction = result.subscription.transactions.first
+
+      transaction.add_ons.size.should == 2
+      add_ons = transaction.add_ons.sort_by { |add_on| add_on.id }
+
+      add_ons.first.id.should == "increase_10"
+      add_ons.first.amount.should == BigDecimal.new("11.00")
+      add_ons.first.quantity.should == 2
+      add_ons.first.number_of_billing_cycles.should == 5
+      add_ons.first.never_expires?.should be_false
+
+      add_ons.last.id.should == "increase_20"
+      add_ons.last.amount.should == BigDecimal.new("21.00")
+      add_ons.last.quantity.should == 3
+      add_ons.last.number_of_billing_cycles.should == 6
+      add_ons.last.never_expires?.should be_false
+
+      transaction.discounts.size.should == 1
+
+      transaction.discounts.first.id.should == "discount_7"
+      transaction.discounts.first.amount.should == BigDecimal.new("7.50")
+      transaction.discounts.first.quantity.should == 2
+      transaction.discounts.first.number_of_billing_cycles.should be_nil
+      transaction.discounts.first.never_expires?.should be_true
+    end
   end
 
   describe "self.create!" do
@@ -480,6 +546,71 @@ describe Braintree::Transaction do
     end
   end
 
+  describe "self.refund" do
+    context "partial refunds" do
+      it "allows partial refunds" do
+        transaction = create_transaction_to_refund
+        result = Braintree::Transaction.refund(transaction.id, transaction.amount / 2)
+        result.success?.should == true
+        result.transaction.type.should == "credit"
+      end
+
+      it "does not allow multiple refunds" do
+        transaction = create_transaction_to_refund
+        Braintree::Transaction.refund(transaction.id, transaction.amount / 2)
+        result = Braintree::Transaction.refund(transaction.id, 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
+      result = Braintree::Transaction.refund(transaction.id)
+      result.success?.should == true
+      result.transaction.type.should == "credit"
+    end
+
+    it "assigns the refund_id on the original transaction" do
+      transaction = create_transaction_to_refund
+      refund_transaction = Braintree::Transaction.refund(transaction.id).transaction
+      transaction = Braintree::Transaction.find(transaction.id)
+
+      transaction.refund_id.should == refund_transaction.id
+    end
+
+    it "assigns the refunded_transaction_id to the original transaction" do
+      transaction = create_transaction_to_refund
+      refund_transaction = Braintree::Transaction.refund(transaction.id).transaction
+
+      refund_transaction.refunded_transaction_id.should == transaction.id
+    end
+
+    it "returns an error if already refunded" do
+      transaction = create_transaction_to_refund
+      result = Braintree::Transaction.refund(transaction.id)
+      result.success?.should == true
+      result = Braintree::Transaction.refund(transaction.id)
+      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,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        }
+      )
+      result = Braintree::Transaction.refund(transaction.id)
+      result.success?.should == false
+      result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::CannotRefundUnlessSettled
+    end
+  end
+
   describe "self.sale" do
     it "returns a successful result with type=sale if successful" do
       result = Braintree::Transaction.sale(
@@ -1260,7 +1391,7 @@ describe Braintree::Transaction do
         result.new_transaction.type.should == "credit"
       end
 
-      it "does not all multiple refunds" do
+      it "does not allow multiple refunds" do
         transaction = create_transaction_to_refund
         transaction.refund(transaction.amount / 2)
         result = transaction.refund(BigDecimal.new("1"))
@@ -1544,7 +1675,7 @@ describe Braintree::Transaction do
       }
     )
 
-    response = Braintree::Http.put "/transactions/#{transaction.id}/settle"
+    response = Braintree::Configuration.instantiate.http.put "/transactions/#{transaction.id}/settle"
     Braintree::Transaction.find(transaction.id)
   end
 end